cmeps_roms.h

Go to the documentation of this file.

#include "cppdefs.h"
      MODULE cmeps_roms_mod
 
#if defined MODEL_COUPLING && defined ESMF_LIB && defined CMEPS
!
!git $Id$
!>
!! \brief   **ROMS** ESMF/NUOPC Cap file for **CMEPS**
!!
!! \details A NUOPC-compliant software layer on top of ROMS to couple to
!!          any Earth System Model (ESM) component through the Community
!!          Mediator for Earth Prediction Systems (CMEPS).
!!
!! \author  Hernan G. Arango (Rutgers University)
!! \date    January 2022
!!
!=======================================================================
!  Copyright (c) 2002-2025 The ROMS Group                              !
!    Licensed under a MIT/X style license         Hernan G. Arango     !
!    See License_ROMS.md                          Ufuk Utku Turuncoglu !
!=======================================================================
!                                                                      !
!  This ESMF/NUOPC module sets ROMS as an ocean gridded component in   !
!  the cdeps/cmeps system:                                             !
!                                                                      !
!                                                                      !
!    ROMS_SetServices        Sets ROMS component shared-object entry   !
!                            points using NUPOC generic methods for    !
!                            "initialize", "run", and "finalize".      !
!                                                                      !
!    ROMS_Create             Allocates module structures and process   !
!                            configuration from input YAML file.       !
!                                                                      !
!    ROMS_SetInitializeP1    ROMS component phase 1 initialization:    !
!                            sets import and export fields long and    !
!                            short names into its respective state.    !
!                                                                      !
!    ROMS_SetInitializeP2    ROMS component phase 2 initialization:    !
!                            Initializes component (ROMS_initialize),  !
!                            sets component grid (ROMS_SetGridArrays), !
!                            and adds fields into import and export    !
!                            into respective states.                   !
!                                                                      !
!    ROMS_DataInit           Exports ROMS component fields during      !
!                            initialization or restart.                !
!                                                                      !
!    ROMS_SetClock           Sets ROMS component date calendar, start  !
!                            and stop times, and coupling interval.    !
# ifdef ESM_SETRUNCLOCK
!                                                                      !
!    ROMS_SetRunClock        Sets ROMS run clock manually.             !
# endif
!                                                                      !
!    ROMS_CheckImport        Checks if ROMS component import field is  !
!                            at the correct time.                      !
!                                                                      !
!    ROMS_SetGridArrays      Sets ROMS component staggered, horizontal !
!                            grid arrays, and land/sea mask if any.    !
!                                                                      !
!    ROMS_SetStates          Adds ROMS component export and import     !
!                            fields into its respective state.         !
!                                                                      !
!    ROMS_ModelAdvance       Advances ROMS component for a coupling    !
!                            interval. It calls import and export      !
!                            routines.                                 !
!                                                                      !
!    ROMS_SetFinalize        Finalizes ROMS component execution.       !
!                                                                      !
!    ROMS_Import             Imports fields into ROMS. The fields are  !
!                            loaded into the snapshot storage arrays   !
!                            to allow time interpolation elsewhere.    !
!                                                                      !
!    ROMS_Export             Exports ROMS fields to other gridded      !
!                            components.                               !
!                                                                      !
!    ROMS_Rotate             Rotates exchanged vector components from  !
!                            computational grid to geographical EAST   !
!                            and NORTH directions or vice versa.       !
!                                                                      !
! 'CMEPS': Community Mediator for Earth Prediction Systems             !
!            'https://escomp.github.io/CMEPS'                          !
!                                                                      !
!  ESMF:   Earth System Modeling Framework (Version 7 or higher)       !
!            'https://www.earthsystemcog.org/projects/esmf'            !
!                                                                      !
!  NUOPC:  National Unified Operational Prediction Capability          !
!            'https://www.earthsystemcog.org/projects/nuopc'           !
!                                                                      !
!  ROMS:   Regional Ocean Modeling System                              !
!            'https://www.myroms.org'                                  !
!                                                                      !
!=======================================================================
!
      USE esmf
      USE nuopc
      USE nuopc_model,                                                  &
     &    nuopc_setservices          => setservices,                    &
     &    nuopc_label_advance        => label_advance,                  &
     &    nuopc_label_datainitialize => label_datainitialize,           &
# ifdef ESM_SETRUNCLOCK
     &    nuopc_label_setrunclock    => label_setrunclock,              &
# endif
     &    nuopc_label_setclock       => label_setclock,                 &
     &    nuopc_label_checkimport    => label_checkimport
!
!-----------------------------------------------------------------------
!  ROMS module association: parameters, variables, derived-type objects.
!-----------------------------------------------------------------------
!
      USE roms_kernel_mod,  ONLY : roms_initialize,                     &
     &                             roms_run,                            &
     &                             roms_finalize
!
      USE bc_2d_mod,        ONLY : bc_r2d_tile
      USE dateclock_mod,    ONLY : roms_clock, caldate, get_date,       &
     &                             time_string
      USE exchange_2d_mod,  ONLY : exchange_r2d_tile,                   &
     &                             exchange_u2d_tile,                   &
     &                             exchange_v2d_tile
      USE get_metadata_mod, ONLY : couplingfield,                       &
     &                             cmeps_metadata,                      &
     &                             metadata_has
      USE mod_kinds,        ONLY : dp, i4b, i8b, r4, r8
      USE mod_forces,       ONLY : forces
      USE mod_grid,         ONLY : grid
      USE mod_iounits,      ONLY : iname, sourcefile, stdout
      USE mod_mixing,       ONLY : mixing
      USE mod_ncparam,      ONLY : iinfo,  idldwn, idlrad, idpair,      &
     &                             idqair, idrain, idsrad, idtair,      &
     &                             idtsur, iduair, idusms, idvair,      &
     &                             idvsms
# ifdef TIME_INTERP
      USE mod_netcdf,       ONLY : netcdf_get_ivar,                     &
     &                             netcdf_get_svar,                     &
     &                             netcdf_get_time
# endif
      USE mod_ocean,        ONLY : ocean
      USE mod_param,        ONLY : bounds, lm, mm, n, nghostpoints,     &
     &                             ngrids, ntilei, ntilej, inlm,        &
     &                             r2dvar, u2dvar, v2dvar
      USE mod_scalars,      ONLY : cp, ewperiodic, nsperiodic, noerror, &
     &                             rclock, dt, exit_flag, itemp, isalt, &
     &                             ntfirst, ntend, ntimes,              &
     &                             rho0, sec2day, tdays, time_ref
      USE mod_stepping,     ONLY : nstp, knew
      USE mp_exchange_mod,  ONLY : mp_exchange2d
      USE stdinp_mod,       ONLY : getpar_i
      USE stdout_mod,       ONLY : set_stdoutunit, stdout_unit
      USE strings_mod,      ONLY : founderror, assign_string, lowercase
      USE yaml_parser_mod,  ONLY : yaml_assignstring,                   &
     &                             yaml_error,                          &
     &                             yaml_svec,                           &
     &                             yaml_get,                            &
     &                             yaml_initialize,                     &
     &                             yaml_tree
!
!-----------------------------------------------------------------------
!  Derived-type structures.
!-----------------------------------------------------------------------
!
      implicit none
!
!  ESM coupling time managing variables and ESMF objects.
!
      TYPE, PRIVATE :: esm_clock
        logical :: restarted
 
        integer (i8b) :: advancecount               ! advance counter
 
        real (dp) :: current_time                   ! seconds
        real (dp) :: time_reference                 ! seconds
        real (dp) :: time_restart                   ! seconds
        real (dp) :: time_start                     ! seconds
        real (dp) :: time_stop                      ! seconds
        real (dp) :: time_step                      ! seconds
!
        character (len=22) :: name
        character (len=22) :: calendarstring        ! 360_day, gregorian
        character (len=22) :: time_referencestring
        character (len=22) :: time_restartstring
        character (len=22) :: time_startstring
        character (len=22) :: time_stopstring
!
        TYPE (esmf_calendar)       :: calendar
        TYPE (esmf_clock)          :: clock
        TYPE (esmf_direction_flag) :: direction
        TYPE (esmf_time)           :: currenttime
        TYPE (esmf_time)           :: referencetime
        TYPE (esmf_time)           :: restarttime
        TYPE (esmf_time)           :: starttime
        TYPE (esmf_time)           :: stoptime
        TYPE (esmf_timeinterval)   :: timestep
      END TYPE esm_clock
!
      TYPE (esm_clock), allocatable, target :: clockinfo(:)
!
! ESM coupled state sets. If appropriate, it includes the logic for
! connecting nested grids.
!
! In other ESM components, the import and export states are defined and
! allocated in the MODELS structure as vectors (see below).
!
      TYPE, PRIVATE :: esm_cplset
        logical, allocatable :: linkedgrid(:,:)       ! connected grid
!
        character (len=100), allocatable :: setlabel(:) ! set label
        character (len=100), allocatable :: explabel(:) ! export label
        character (len=100), allocatable :: implabel(:) ! import label
      END TYPE esm_cplset
!
      TYPE (esm_cplset), allocatable, target :: coupled(:)
!
!  Import and export fields metadata information.
!
      TYPE, PRIVATE :: esm_field
        logical :: connected                  ! connected to coupler
        logical :: debug_write                ! write exchanged field
!
        integer :: gtype                      ! field grid mesh type
        integer :: itype                      ! field interpolation flag
        integer :: tindex                     ! rolling two-time indices
!
        character (len=:), allocatable :: short_name    ! short name
        character (len=:), allocatable :: standard_name ! standard name
        character (len=:), allocatable :: long_name     ! long name
        character (len=:), allocatable :: dst_gtype     ! DST grid type
        character (len=:), allocatable :: dst_units     ! DST units
        character (len=:), allocatable :: src_gtype     ! SRC grid type
        character (len=:), allocatable :: src_units     ! SRC units
        character (len=:), allocatable :: nc_vname      ! DATA Vname
        character (len=:), allocatable :: nc_tname      ! DATA Tname
        character (len=:), allocatable :: map_norm      ! mapping norm
        character (len=:), allocatable :: map_type      ! regrid method
!
        character (len=22)  :: datestring(2)  ! snapshots date
!
        real (dp) :: scale_factor             ! field scale factor
        real (dp) :: add_offset               ! field add offset value
        real (dp) :: tmin                     ! DATA time minimum value
        real (dp) :: tmax                     ! DATA time maximum value
        real (dp) :: tstr                     ! DATA lower time-snapshot
        real (dp) :: tend                     ! DATA upper time-snapshot
        real (dp) :: tintrp(2)                ! interpolation time (day)
        real (dp) :: vtime(2)                 ! latest two-time values
!
        TYPE (esmf_routehandle) :: rhandle    ! field RouteHandle
      END TYPE esm_field
!
!  Import and export fields mesh data.
!
      TYPE, PRIVATE :: esm_mesh
        integer :: gid                           ! grid ID
        integer :: gtype                         ! grid mesh type
 
        integer (i4b), allocatable :: mask(:,:)  ! grid land/sea mask
 
        real (r8), allocatable :: lon(:,:)       ! grid longitude
        real (r8), allocatable :: lat(:,:)       ! grid latitude
        real (r8), allocatable :: area(:,:)      ! grid area
      END TYPE esm_mesh
!
!  Coupled models high-level object, [Nmodels].
!
      TYPE, PRIVATE :: esm_model
        logical :: isactive                       ! active for coupling
!
        integer (i4b) :: landvalue                ! land mask value
        integer (i4b) :: seavalue                 ! sea  mask value
 
        integer :: ngrids                         ! number nested grids
 
        integer :: exportcalls                    ! export CALL counter
        integer :: importcalls                    ! import CALL counter
 
        integer :: npets                          ! number model PETs
        integer, allocatable :: petlist(:)        ! component PETs list
 
        integer, allocatable :: timefrac(:,:)     ! driver time fraction
!
        character (len=:), allocatable :: name    ! component name
!
        TYPE (esmf_grid),  allocatable :: grid(:)        ! grid object
        TYPE (esm_mesh),   allocatable :: mesh(:)        ! mesh
        TYPE (esm_field),  allocatable :: importfield(:) ! import fields
        TYPE (esm_field),  allocatable :: exportfield(:) ! export fields
        TYPE (esmf_state), allocatable :: importstate(:) ! import state
        TYPE (esmf_state), allocatable :: exportstate(:) ! export state
      END TYPE esm_model
!
      TYPE (esm_model), allocatable, target :: models(:)
!
!-----------------------------------------------------------------------
!  Internal module paramters and variables.
!-----------------------------------------------------------------------
!
!  Switch to trace/track run sequence during debugging.  All information
!  is written to Fortan unit trac. For now, use standard output unit.
!
      logical :: esm_track = .true.  ! trace/track CALL sequence switch
!
!  Number of coupled ESM gridded components and identification index
!
      integer, parameter :: nmodels = 1
      integer, parameter :: idriver = 0
      integer, parameter :: iroms   = 1
!
!  Number of ROMS export and import fields per component.
!
      integer, allocatable :: nexport(:)
      integer, allocatable :: nimport(:)
!
!  Model coupling type: [1] Explicit, [otherwise] Semi-Implicit.
!
!  In explicit coupling, exchange fields at the next time-step are
!  defined using known values from the time-step before it. Explicit
!  methods require less computational effort and are accurate for
!  small coupling time-steps.
!
!  In implicit coupling, exchange fields at the next time-step are
!  defined by including values at the next time-step. Implicit methods
!  are stable and allow longer coupling time-steps but are expensier.
!
!  In semi-implicit coupling, ROMS -> ATM is explicit, ATM -> ROMS is
!  implicit.
!
      integer :: couplingtype = 1
!
!  Linked/coupled ROMS nested grid number.
!
      integer :: linked_grid
!
!  Distributed-memory communicator handle for each component, rank of
!  each PET, and PET layout (sequential or concurrent).
!
      integer, allocatable :: esmcomm(:)
      integer :: petrank
      character (len=10), allocatable :: petlayoutoption(:)
!
!  Coupling debugging flag:
!
!    [0] no debugging
!    [1] reports informative messages
!    [2] '1' plus writes grid information in VTK format
!    [3] '2' plus writes exchage fields into NetCDF files
!
      integer :: debuglevel = 0
!
!  Execution tracing level flag:
!
!    [0] no tracing
!    [1] reports sequence of coupling subroutine calls
!    [2] <1> plus writes voluminous ESMF library tracing
!            information which slowdown performace, and
!            creates large log file
!
      integer :: tracelevel = 0
!
!  Standard output units.
!
      integer :: cplout = 77          ! coupling driver
      integer :: trac   = 6           ! trace/track CALL sequence unit
!
      character (len=11), parameter :: couplerlog = 'log.coupler'
!
!  Coupled model staggered grid-cell type indices:
!
!     Arakawa B-grid    Arakawa C-grid
!
!     q --------- q     q --- v --- q
!     |           |     |           |
!     |     c     |     u     c     u
!     |           |     |           |
!     q --------- q     q --- v --- q
!
!  COAMPS, C-grid
!  RegCM,  B-grid
!  ROMS,   C-grid        (c = RHO-point,  q = PSI-point)
!  WRF,    C-grid
!
      integer, parameter :: inan    = 0     ! unstaggered, cell center
      integer, parameter :: icenter = 1     ! cell center
      integer, parameter :: icorner = 2     ! cell corners
      integer, parameter :: iupoint = 3     ! right and left cell faces
      integer, parameter :: ivpoint = 4     ! upper and lower cell faces
!
      character (len=6), dimension(0:4) :: gridtype =                   &
     &                                     (/ 'N/A   ',                 &
     &                                        'Center',                 &
     &                                        'Corner',                 &
     &                                        'U     ',                 &
     &                                        'V     ' /)
!
!  REGRID interpolation method between source and destination fields.
!
      integer, parameter :: inone   = 0     ! none
      integer, parameter :: ibilin  = 1     ! bilinear
      integer, parameter :: ipatch  = 2     ! high-order patch recovery
      integer, parameter :: iconsvd = 3     ! 1st-order conservative, D
      integer, parameter :: iconsvf = 4     ! 1st-order conservative, F
      integer, parameter :: ifcopy  = 5     ! redist
      integer, parameter :: instod  = 6     ! nearest Src 2 Dst
      integer, parameter :: instodd = 7     ! nearest Src 2 Dst, consv D
      integer, parameter :: instodf = 8     ! nearest Src 2 Dst, consv F
!
!  Standard input filename for each coupled model, [Nmodels].
!
      character (len=256), allocatable :: inpname(:)
!
!  ROMS coupling YAML configuration filename.
!
      character (len=:), allocatable :: cplname
!
!  Today date string.
!
      character (len=44) :: todaydatestring
!
!  Git URL and Revision.
!
      character (len=80)  :: git_url
      character (len=256) :: git_rev
!
!  ESM strings.
!
      character (len=:), allocatable :: coupledset
      character (len=:), allocatable :: exportstatename
      character (len=:), allocatable :: importstatename
!
!  ESM constants.
!
      integer (i4b), parameter :: mapped_mask = 99_i4b
      integer (i4b), parameter :: unmapped_mask = 98_i4b
 
      real (dp), parameter :: missing_dp = 1.0e20_dp
      real (r4), parameter :: missing_r4 = 1.0e20_r4
      real (r8), parameter :: missing_r8 = 1.0e20_r8
 
      real (dp), parameter :: tol_dp = 0.001e20_dp
      real (r4), parameter :: tol_r4 = 0.001e20_r4
      real (r8), parameter :: tol_r8 = 0.001e20_r8
!
!  Specific parameters for cmeps.
!
      integer :: scalarfieldcount
      integer :: scalarfieldidxgridnx
      integer :: scalarfieldidxgridny
 
      character (len=256) :: scalarfieldname
!
!-----------------------------------------------------------------------
      PUBLIC  :: roms_setservices
!-----------------------------------------------------------------------
!
      PRIVATE :: roms_create
      PRIVATE :: roms_setinitializep1
      PRIVATE :: roms_setinitializep2
      PRIVATE :: roms_datainit
      PRIVATE :: roms_setclock
# ifdef ESM_SETRUNCLOCK
      PRIVATE :: roms_setrunclock
# endif
      PRIVATE :: roms_checkimport
      PRIVATE :: roms_setgridarrays
      PRIVATE :: roms_setstates
      PRIVATE :: roms_modeladvance
      PRIVATE :: roms_setfinalize
      PRIVATE :: roms_import
      PRIVATE :: roms_export
      PRIVATE :: roms_rotate
      PRIVATE :: createscalarfield
      PRIVATE :: setscalarfieldvalues
      PRIVATE :: field_index
      PRIVATE :: report_timestamp
!
      PRIVATE
!
!  Define parameters to rotate exchanged fields from geographical (EAST,
!  NORTH) to computational directions or vice versa. The resulting
!  vector components can be staggered (U- and V-points) or at cell
!  center (RHO-points: full or interior grid).
!
      integer, parameter :: geo2grid     = 0        ! U- and V-points
      integer, parameter :: geo2grid_rho = 0        ! RHO-points
      integer, parameter :: grid2geo_rho = 1        ! export vector
!
!-----------------------------------------------------------------------
      CONTAINS
!-----------------------------------------------------------------------
!
      SUBROUTINE roms_setservices (model, rc)
!
!=======================================================================
!                                                                      !
!  Sets ROMS component shared-object entry points for "initialize",    !
!  "run", and "finalize" by using NUOPC generic methods.               !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(out) :: rc
!
      TYPE (esmf_gridcomp) :: model
!
!  Local variable declarations.
!
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", ROMS_SetServices"
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '==> Entering ROMS_SetServices',        &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  Register NUOPC generic routines.
!-----------------------------------------------------------------------
!
      CALL nuopc_compderive (model,                                     &
     &                       nuopc_setservices,                         &
     &                       rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Register initialize routines.
!-----------------------------------------------------------------------
!
!  Set routine for Phase 1 initialization (import and export fields).
!
      CALL nuopc_compsetentrypoint (model,                              &
     &                              methodflag=esmf_method_initialize,  &
     &                              phaselabellist=(/"IPDv00p1"/),      &
     &                              userroutine=roms_setinitializep1,   &
     &                              rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Set routine for Phase 2 initialization (exchange arrays).
!
      CALL nuopc_compsetentrypoint (model,                              &
     &                              methodflag=esmf_method_initialize,  &
     &                              phaselabellist=(/"IPDv00p2"/),      &
     &                              userroutine=roms_setinitializep2,   &
     &                              rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Attach ROMS component phase independent specializing methods.
!-----------------------------------------------------------------------
!
!  Set routine for export initial/restart fields.
!
      CALL nuopc_compspecialize (model,                                 &
     &                           speclabel=nuopc_label_datainitialize,  &
     &                           specroutine=roms_datainit,             &
     &                           rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Set routine for setting ROMS clock.
!
      CALL nuopc_compspecialize (model,                                 &
     &                           speclabel=nuopc_label_setclock,        &
     &                           specroutine=roms_setclock,             &
     &                           rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
 
# ifdef ESM_SETRUNCLOCK
!
!  Set routine for setting ROMS run clock manually. First, remove the
!  default.
!
      CALL esmf_methodremove (model,                                    &
     &                        nuopc_label_setrunclock,                  &
     &                        rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      CALL nuopc_compspecialize (model,                                 &
     &                           speclabel=nuopc_label_setrunclock,     &
     &                           specroutine=roms_setrunclock,          &
     &                           rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
# endif
!
!  Set routine for checking import state.
!
      CALL nuopc_compspecialize (model,                                 &
     &                           speclabel=nuopc_label_checkimport,     &
     &                           specphaselabel="RunPhase1",            &
     &                           specroutine=roms_checkimport,          &
     &                           rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Set routine for time-stepping ROMS component.
!
      CALL nuopc_compspecialize (model,                                 &
     &                           speclabel=nuopc_label_advance,         &
     &                           specroutine=roms_modeladvance,         &
     &                           rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Register ROMS finalize routine.
!-----------------------------------------------------------------------
!
      CALL esmf_gridcompsetentrypoint (model,                           &
     &                                 methodflag=esmf_method_finalize, &
     &                                 userroutine=roms_setfinalize,    &
     &                                 rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '<== Exiting  ROMS_SetServices',        &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
!
      RETURN
      END SUBROUTINE roms_setservices
!
      SUBROUTINE roms_create (localPET, PETcount, MyComm, rc)
!
!=======================================================================
!                                                                      !
!  It allocates module structures and process configuration from input !
!  YAML file.                                                          !
!                                                                      !
!=======================================================================
!
      USE mod_strings
!
!  Imported variable declarations.
!
      integer, intent(in ) :: localpet, petcount, mycomm
      integer, intent(out) :: rc
!
!  Local variable declarations.
!
# ifdef METADATA_REPORT
      logical :: lreport = .true.                ! dumps YAML dictionary
# else
      logical :: lreport = .false.
# endif
      logical :: lexist, masterpet
!
      integer :: findex, i, layout, ng
!
      TYPE (couplingfield), allocatable :: export(:), import(:)
      TYPE (yaml_svec), allocatable     :: estring(:), istring(:)
      TYPE (yaml_tree)                  :: yml
!
      character (len=240) :: standardname, shortname
      character (len=256) :: string
 
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", ROMS_Create"
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '==> Entering ROMS_Create',             &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  Create YAML dictionary object (TYPE yaml_tree).
!-----------------------------------------------------------------------
!
      IF (yaml_error(yaml_initialize(yml, trim(cplname), lreport),      &
     &               noerror, __line__, myfile)) THEN
        IF (localpet.eq.0) WRITE (cplout,10) trim(cplname)
        rc=esmf_rc_file_read
        RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Get ROMS standard input filename.
!-----------------------------------------------------------------------
!
     IF (yml%has('standard_input.OCN_component')) THEN
         IF (founderror(yaml_get(yml, 'standard_input.OCN_component',    &
     &                           string),                                &
     &                 noerror, __line__, myfile)) THEN
          rc=esmf_rc_copy_fail
          RETURN
        END IF
        iname=trim(string)
      ELSE
        rc=esmf_rc_not_found
        IF (localpet.eq.0) WRITE (cplout,20)                            &
     &                                  'standard_input.OCN_component', &
     &                                       trim(cplname)
        RETURN
      END IF
!
!  Get size of number of nested grids, 'Ngrids' parameter from ROMS
!  standard input file.
!
      masterpet=localpet.eq.0
      CALL getpar_i (masterpet, ngrids, 'Ngrids', trim(iname))
!
!-----------------------------------------------------------------------
!  Get ROMS linked/coupled nested grid number for current application.
!-----------------------------------------------------------------------
!
      IF (yml%has('linked_grid')) THEN
        IF (founderror(yaml_get(yml, 'linked_grid',                     &
     &                          linked_grid),                           &
     &                 noerror, __line__, myfile)) THEN
          rc=esmf_rc_copy_fail
          RETURN
        END IF
      ELSE
        linked_grid=1
      END IF
!
!-----------------------------------------------------------------------
!  Allocate 'cap' module structure and variables.
!-----------------------------------------------------------------------
!
!  Coupled model(s) high-level objects.
!
      IF (.not.allocated(clockinfo)) THEN
        allocate ( clockinfo(0:nmodels) )         ! TYPE ESM_Clock
      END IF
!
      IF (.not.allocated(coupled)) THEN
        allocate ( coupled(nmodels) )             ! TYPE ESM_CplSet
      END IF
!
      IF (.not.allocated(models)) THEN
        allocate ( models(nmodels) )              ! TYPE ESM_Model
      END IF
!
!  Number of export and import fields per component.
!
      IF (.not.allocated(nexport)) THEN
        allocate ( nexport(nmodels) )
      END IF
!
      IF (.not.allocated(nimport)) THEN
        allocate ( nimport(nmodels) )
      END IF
!
!  Allocate and set several variables that depend on the number of ROMS
!  nested grids.
!
      IF (.not.allocated(esmcomm)) THEN
        allocate ( esmcomm(nmodels) )             ! mpi-communicator
      END IF
      esmcomm(iroms)=mycomm
!
      IF (.not.allocated(petlayoutoption)) THEN
        allocate ( petlayoutoption(nmodels) )     ! PET layout
      END IF
!
      IF (.not.allocated(inpname)) THEN
        allocate ( inpname(nmodels) )             ! standard input files
      END IF
      inpname(iroms)=trim(iname)
!
      IF (.not.allocated(models(iroms)%grid)) THEN
        allocate ( models(iroms)%grid(ngrids) )
      END IF
!
      IF (.not.allocated(coupled(iroms)%LinkedGrid)) THEN
        allocate ( coupled(iroms)%LinkedGrid(ngrids,nmodels) )
        coupled(iroms)%LinkedGrid=.false.
      END IF
      coupled(iroms)%LinkedGrid(linked_grid,:)=.true.
!
      IF (.not.allocated(coupled(iroms)%SetLabel)) THEN
        allocate ( coupled(iroms)%SetLabel(ngrids) )
      END IF
!
      IF (.not.allocated(coupled(iroms)%ExpLabel)) THEN
        allocate ( coupled(iroms)%ExpLabel(ngrids) )
      END IF
!
      IF (.not.allocated(coupled(iroms)%ImpLabel)) THEN
        allocate ( coupled(iroms)%ImpLabel(ngrids) )
      END IF
!
      IF (.not.allocated(models(iroms)%TimeFrac)) THEN
        allocate ( models(iroms)%TimeFrac(ngrids,nmodels) )
        models(iroms)%TimeFrac=0
      END IF
      models(iroms)%TimeFrac(linked_grid,:)=1
!
!  Initialize module various variables.
!
      models(iroms)%Ngrids=ngrids
      models(iroms)%IsActive=.true.
      clockinfo(idriver)%Restarted=.false.
      clockinfo(iroms  )%Restarted=.false.
!
      IF (founderror(assign_string(models(iroms)%name,                  &
     &                             'ROMS'),                             &
     &               noerror, __line__, myfile)) THEN
          rc=esmf_rc_copy_fail
          RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Process export field(s) metadata from YAML object.
!-----------------------------------------------------------------------
!
!  Allocate ExportState structure. It is still needed if there are no
!  fields to export. It is needed for the 'scalar field' named
!  'cpl_scalars' (see nems.configure) used by cmeps.
!
      IF (.not.allocated(models(iroms)%ExportState)) THEN
        allocate ( models(iroms)%ExportState(ngrids) )
      END IF
!
!  Get export variables short name to process.
!
      IF (yml%has('export_variables')) THEN
        IF (founderror(yaml_get(yml, 'export_variables',                 &
     &                          estring),                                &
     &                 noerror, __line__, myfile)) THEN
          rc=esmf_rc_copy_fail
          RETURN
        END IF
        nexport(iroms)=SIZE(estring)
      ELSE
        nexport(iroms)=0                           ! no fields to export
      END IF
!
!  Extract export field metadata from dictionary.
!
      IF (nexport(iroms).gt.0) THEN
        IF (yml%has('export')) THEN
          CALL cmeps_metadata (yml, trim(cplname), 'export',            &
     &                         export)
          IF (yaml_error(exit_flag, noerror, __line__, myfile)) THEN
            rc=esmf_rc_val_wrong
            RETURN
          END IF
        ELSE
          rc=esmf_rc_not_found
          IF (localpet.eq.0) WRITE (cplout,20) 'export',                &
     &                                         trim(cplname)
          RETURN
        END IF
!
!  Allocate export fields structure (TYPE ESM_Fields).
!
        IF (.not.allocated(models(iroms)%ExportField)) THEN
          allocate ( models(iroms)%ExportField(nexport(iroms)) )
        END IF
!
!  Load export field(s) metadata.
!
        DO i=1,nexport(iroms)
          shortname=estring(i)%value
          findex=metadata_has(export, trim(shortname))
          IF (findex.gt.0) THEN
            models(iroms)%ExportField(i)%connected=                     &
     &                                   export(findex)%connected
            models(iroms)%ExportField(i)%debug_write=                   &
     &                                   export(findex)%debug_write
!
            models(iroms)%ExportField(i)%add_offset=                    &
     &                                   export(findex)%add_offset
            models(iroms)%ExportField(i)%scale_factor=                  &
     &                                   export(findex)%scale
!
!                                      field short name
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ExportField(i)%short_name,     &
     &                     export(findex)%short_name),                  &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      field standard name
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ExportField(i)%standard_name,  &
     &                     export(findex)%standard_name),               &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      field descriptive long name
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ExportField(i)%long_name,      &
     &                     export(findex)%long_name),                   &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      field mapping normalization type
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ExportField(i)%map_norm,       &
     &                     export(findex)%map_norm),                    &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      field reggriding method
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ExportField(i)%map_type,       &
     &                     export(findex)%map_type),                    &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      destination field grid-cell type
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ExportField(i)%dst_gtype,      &
     &                     export(findex)%destination_grid),            &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      destination field units
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ExportField(i)%dst_units,      &
     &                     export(findex)%destination_units),           &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      source field grid-cell type
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ExportField(i)%src_gtype,      &
     &                     export(findex)%source_grid),                 &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      source field units
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ExportField(i)%src_units,      &
     &                     export(findex)%source_units),                &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      DATA NetCDF variable name
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ExportField(i)%nc_vname,       &
     &                     export(findex)%data_netcdf_vname),           &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      DATA NetCDF time variable name
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ExportField(i)%nc_tname,       &
     &                     export(findex)%data_netcdf_tname),           &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!
!  Set grid type flag.
!
            SELECT CASE (lowercase(export(findex)%source_grid))
              CASE ('center_cell', 'cell_center', 'center')
                models(iroms)%ExportField(i)%gtype=icenter
              CASE ('corner_cell', 'cell_corner', 'corner')
                models(iroms)%ExportField(i)%gtype=icorner
              CASE ('left_right_edge', 'right_left_edge', 'edge1')
                models(iroms)%ExportField(i)%gtype=iupoint
              CASE ('lower_upper_edge', 'upper_lower_edge', 'edge2')
                models(iroms)%ExportField(i)%gtype=ivpoint
              CASE DEFAULT
                models(iroms)%ExportField(i)%gtype=icenter
            END SELECT
!
!  Set map type flag.
!
            SELECT CASE (lowercase(export(findex)%map_type))
              CASE ('mapbilnr')
                models(iroms)%ExportField(i)%itype=ibilin
              CASE ('mappatch')
                models(iroms)%ExportField(i)%itype=ipatch
              CASE ('mapconsd')
                models(iroms)%ExportField(i)%itype=iconsvd
              CASE ('mapconsf')
                models(iroms)%ExportField(i)%itype=iconsvf
              CASE ('mapfcopy')
                models(iroms)%ExportField(i)%itype=ifcopy
              CASE ('mapnstod')
                models(iroms)%ExportField(i)%itype=instod
              CASE ('mapnstod_consd')
                models(iroms)%ExportField(i)%itype=instodd
              CASE ('mapnstod_consf')
                models(iroms)%ExportField(i)%itype=instodf
              CASE DEFAULT
                models(iroms)%ExportField(i)%itype=inone
            END SELECT
!
!  Check if field exits in NUOPC dictionary.
!
            lexist=nuopc_fielddictionaryhasentry(                       &
     &                     models(iroms)%ExportField(i)%standard_name,  &
     &                                        rc=rc)
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
!
!  If appropriate, add field to NUOPC dictionary.
!
            IF (.not.lexist) THEN
              CALL nuopc_fielddictionaryaddentry(                       &
     &                     models(iroms)%ExportField(i)%standard_name,  &
     &                                         canonicalunits =         &
     &                     models(iroms)%ExportField(i)%src_units,      &
     &                                         rc=rc)
              IF (esmf_logfounderror(rctocheck=rc,                      &
     &                               msg=esmf_logerr_passthru,          &
     &                               line=__line__,                     &
     &                               file=myfile)) THEN
                RETURN
              END IF
            END IF
          ELSE
            IF (localpet.eq.0) THEN
              WRITE (cplout,30) 'export field short_name: ',            &
     &                          trim(shortname), trim(cplname)
            END IF
            rc=esmf_rc_not_found
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
          END IF
        END DO
      END IF
!
!-----------------------------------------------------------------------
!  Process import field(s) metadata from YAML object.
!-----------------------------------------------------------------------
!
!  Get import variables short name to process.
!
      IF (yml%has('import_variables')) THEN
        IF (founderror(yaml_get(yml, 'import_variables',                 &
     &                          istring),                                &
     &                 noerror, __line__, myfile)) THEN
          rc=esmf_rc_copy_fail
          RETURN
        END IF
        nimport(iroms)=SIZE(istring)
      ELSE
        nimport(iroms)=0                           ! no fields to import
      END IF
 
!  Extract ROMS import field(s) metadata for YML dictionary.
!
      IF (nimport(iroms).gt.0) THEN
        IF (yml%has('import')) THEN
          CALL cmeps_metadata (yml, trim(cplname), 'import',            &
     &                         import)
          IF (yaml_error(exit_flag, noerror, __line__, myfile)) THEN
            rc=esmf_rc_val_wrong
            RETURN
          END IF
        ELSE
          rc=esmf_rc_not_found
          IF (localpet.eq.0) WRITE (cplout,20) 'import',                &
     &                                         trim(cplname)
          RETURN
        END IF
!
!  Allocate import fields structure (TYPE ESM_Fields).
!
        IF (.not.allocated(models(iroms)%ImportField)) THEN
          allocate ( models(iroms)%ImportField(nimport(iroms)) )
        END IF
!
        IF (.not.allocated(models(iroms)%ImportState)) THEN
          allocate ( models(iroms)%ImportState(ngrids) )
        END IF
!
!  Load import field(s) metadata.
!
        DO i=1,nimport(iroms)
          shortname=istring(i)%value
          findex=metadata_has(import, trim(shortname))
          IF (findex.gt.0) THEN
            models(iroms)%ImportField(i)%connected=                     &
     &                                   import(findex)%connected
            models(iroms)%ImportField(i)%debug_write=                   &
     &                                   import(findex)%debug_write
!
            models(iroms)%ImportField(i)%add_offset=                    &
     &                                   import(findex)%add_offset
            models(iroms)%ImportField(i)%scale_factor=                  &
     &                                   import(findex)%scale
!
!                                      field short name
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ImportField(i)%short_name,     &
     &                     import(findex)%short_name),                  &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      field standard name
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ImportField(i)%standard_name,  &
     &                     import(findex)%standard_name),               &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      field descriptive long name
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ImportField(i)%long_name,      &
     &                     import(findex)%long_name),                   &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      field mapping normalization type
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ImportField(i)%map_norm,       &
     &                     import(findex)%map_norm),                    &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      field reggriding method
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ImportField(i)%map_type,       &
     &                     import(findex)%map_type),                    &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      destination field grid-cell type
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ImportField(i)%dst_gtype,      &
     &                     import(findex)%destination_grid),            &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      destination field units
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ImportField(i)%dst_units,      &
     &                     import(findex)%destination_units),           &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      source field grid-cell type
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ImportField(i)%src_gtype,      &
     &                     import(findex)%source_grid),                 &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      source field units
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ImportField(i)%src_units,      &
     &                     import(findex)%source_units),                &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      DATA NetCDF variable name
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ImportField(i)%nc_vname,       &
     &                     import(findex)%data_netcdf_vname),           &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!                                      DATA NetCDF time variable name
            IF (founderror(assign_string(                               &
     &                     models(iroms)%ImportField(i)%nc_tname,       &
     &                     import(findex)%data_netcdf_tname),           &
     &                   noerror, __line__, myfile)) THEN
              rc=esmf_rc_copy_fail
              RETURN
            END IF
!
!  Set grid type flag.
!
            SELECT CASE (lowercase(import(findex)%destination_grid))
              CASE ('center_cell', 'cell_center', 'center')
                models(iroms)%ImportField(i)%gtype=icenter
              CASE ('corner_cell', 'cell_corner', 'corner')
                models(iroms)%ImportField(i)%gtype=icorner
              CASE ('left_right_edge', 'right_left_edge', 'edge1')
                models(iroms)%ImportField(i)%gtype=iupoint
              CASE ('lower_upper_edge', 'upper_lower_edge', 'edge2')
                models(iroms)%ImportField(i)%gtype=ivpoint
              CASE DEFAULT
                models(iroms)%ImportField(i)%gtype=icenter
            END SELECT
!
!  Set map type flag.
!
            SELECT CASE (lowercase(import(findex)%map_type))
              CASE ('mapbilnr')
                models(iroms)%ImportField(i)%itype=ibilin
              CASE ('mappatch')
                 models(iroms)%ImportField(i)%itype=ipatch
              CASE ('mapconsd')
                models(iroms)%ImportField(i)%itype=iconsvd
              CASE ('mapconsf')
                models(iroms)%ImportField(i)%itype=iconsvf
              CASE ('mapfcopy')
                models(iroms)%ImportField(i)%itype=ifcopy
              CASE ('mapnstod')
                models(iroms)%ImportField(i)%itype=instod
              CASE ('mapnstod_consd')
                models(iroms)%ImportField(i)%itype=instodd
              CASE ('mapnstod_consf')
                models(iroms)%ImportField(i)%itype=instodf
              CASE DEFAULT
                models(iroms)%ImportField(i)%itype=inone
            END SELECT
!
!  Check if field exits in NUOPC dictionary.
!
            lexist=nuopc_fielddictionaryhasentry(                       &
     &                     models(iroms)%ImportField(i)%standard_name,  &
     &                                        rc=rc)
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
!
!  If appropriate, add field to NUOPC dictionary.
!
            IF (.not.lexist) THEN
              CALL nuopc_fielddictionaryaddentry(                       &
     &                     models(iroms)%ImportField(i)%standard_name,  &
     &                                         canonicalunits =         &
     &                     models(iroms)%ImportField(i)%src_units,      &
     &                                         rc=rc)
              IF (esmf_logfounderror(rctocheck=rc,                      &
     &                               msg=esmf_logerr_passthru,          &
     &                               line=__line__,                     &
     &                               file=myfile)) THEN
                RETURN
              END IF
            END IF
          ELSE
            IF (localpet.eq.0) THEN
              WRITE (cplout,30) 'import field short_name: ',            &
     &                          trim(shortname), trim(cplname)
            END IF
            rc=esmf_rc_not_found
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
          END IF
        END DO
      END IF
!
!-----------------------------------------------------------------------
!  Extract other configuration parameters from YAML object.
!-----------------------------------------------------------------------
!
!  Coupling type: explicit or semi-implicit.
!
      IF (yml%has('CouplingType')) THEN
        IF (founderror(yaml_get(yml, 'CouplingType',                    &
     &                          couplingtype),                          &
     &                 noerror, __line__, myfile)) THEN
          rc=esmf_rc_copy_fail
          RETURN
        END IF
      ELSE
        rc=esmf_rc_not_found
        IF (localpet.eq.0) WRITE (cplout,20) 'CouplingType',            &
     &                                       trim(cplname)
        RETURN
      END IF
!
!  PET layout: sequential or concurrent.
!
      IF (yml%has('PETlayoutOption')) THEN
        IF (founderror(yaml_get(yml, 'PETlayoutOption',                 &
     &                          layout),                                &
     &                 noerror, __line__, myfile)) THEN
          rc=esmf_rc_copy_fail
          RETURN
        END IF
      END IF
!
      SELECT CASE (layout)
        CASE (0)
          petlayoutoption(iroms)='SEQUENTIAL'
        CASE (1)
          petlayoutoption(iroms)='CONCURRENT'
      END SELECT
!
!  Coupled state labels.
!
      IF (yml%has('CoupledSet')) THEN
        IF (founderror(yaml_get(yml, 'CoupledSet',                      &
     &                          string),  &
     &                 noerror, __line__, myfile)) THEN
          rc=esmf_rc_copy_fail
          RETURN
        END IF
        coupled(iroms)%SetLabel(linked_grid)=trim(string)
      END IF
!
      IF (yml%has('ExportState')) THEN
        IF (founderror(yaml_get(yml, 'ExportState',                     &
     &                          string),                                &
     &                 noerror, __line__, myfile)) THEN
          rc=esmf_rc_copy_fail
          RETURN
        END IF
        coupled(iroms)%ExpLabel(linked_grid)=trim(string)
      END IF
!
      IF (yml%has('ImportState')) THEN
        IF (founderror(yaml_get(yml, 'ImportState',                     &
     &                          string),  &
     &                 noerror, __line__, myfile)) THEN
          rc=esmf_rc_copy_fail
          RETURN
        END IF
        coupled(iroms)%ImpLabel(linked_grid)=trim(string)
      END IF
!
!  Coupling debugging flag.
!
      IF (yml%has('DebugLevel')) THEN
        IF (founderror(yaml_get(yml, 'DebugLevel',                      &
     &                          debuglevel),                            &
     &                 noerror, __line__, myfile)) THEN
          rc=esmf_rc_copy_fail
          RETURN
        END IF
      END IF
!
!  Execution tracing flag.
!
      IF (yml%has('TraceLevel')) THEN
        IF (founderror(yaml_get(yml, 'TraceLevel',                      &
     &                          tracelevel),                            &
     &                 noerror, __line__, myfile)) THEN
          rc=esmf_rc_copy_fail
          RETURN
        END IF
      END IF
!
!  Destroy YAML obeject and deallocate local structures.
!
      CALL yml%destroy ()
      IF (allocated(export))  deallocate (export)
      IF (allocated(import))  deallocate (import)
      IF (allocated(estring)) deallocate (estring)
      IF (allocated(istring)) deallocate (istring)
!
!-----------------------------------------------------------------------
!  Report specified import and export states.
!-----------------------------------------------------------------------
!
      git_url=git_url
      git_rev=git_rev
!
      IF (localpet.eq.0) THEN
        CALL get_date (todaydatestring)
        WRITE (cplout,40) trim(esmf_version_string),                    &
     &                    trim(todaydatestring),                        &
     &                    trim(git_url),                                &
     &                    trim(git_rev),                                &
     &                    trim(my_os),                                  &
     &                    trim(my_cpu),                                 &
     &                    trim(my_fort),                                &
     &                    trim(my_fc),                                  &
     &                    trim(my_fflags),                              &
     &                    mycomm, petcount
        WRITE (cplout,50) 'Coupling Input Metadata Filename = ',        &
     &                    trim(cplname)
        WRITE (cplout,50) '  ROMS Input Parameters Filename = ',        &
     &                    trim(iname)
        WRITE (cplout,'(a)') char(32)              ! blank space
        WRITE (cplout,60) '          Number of nested grids = ',        &
                          ngrids
        WRITE (cplout,60) '             Coupled nested grid = ',        &
     &                    linked_grid
        IF (couplingtype.eq.1) THEN
          WRITE (cplout,70) '                   Coupling flag = ',      &
     &                      couplingtype,                               &
     &                      ',  Explicit coupling method'
        ELSE IF (couplingtype.eq.2) THEN
          WRITE (cplout,70) '                   Coupling flag = ',      &
     &                      couplingtype,                               &
     &                      ',  Semi-Implicit coupling method'
        END IF
        IF (layout.eq.0) THEN
          WRITE (cplout,70) '              PETs layout option = ',      &
     &                      layout,                                     &
     &                      ',  Sequential'
        ELSE IF (layout.eq.1) THEN
          WRITE (cplout,70) '              PETs layout option = ',      &
     &                      layout,                                     &
     &                      ',  Concurrent'
        END IF
        WRITE (cplout,'(a)') char(32)
        WRITE (cplout,60) '   Coupling debugging level flag = ',        &
     &                    debuglevel
        WRITE (cplout,60) '    Execution tracing level flag = ',        &
     &                    tracelevel
!
        IF (nimport(iroms).gt.0) THEN
          WRITE (cplout,80) 'ROMS IMPORT Fields Metadata:'
          DO i=1,nimport(iroms)
            WRITE (cplout,90)                                           &
     &              trim(models(iroms)%ImportField(i)%short_name),      &
     &              trim(models(iroms)%ImportField(i)%standard_name),   &
     &              models(iroms)%ImportField(i)%gtype,                 &
     &              models(iroms)%ImportField(i)%itype,                 &
     &              models(iroms)%ImportField(i)%connected,             &
     &              models(iroms)%ImportField(i)%debug_write,           &
     &              models(iroms)%ImportField(i)%add_offset,            &
     &              models(iroms)%ImportField(i)%scale_factor
          END DO
        END IF
!
        IF (nexport(iroms).gt.0) THEN
          WRITE (cplout,80) 'ROMS EXPORT Fields Metadata:'
          DO i=1,nexport(iroms)
            WRITE (cplout,90)                                           &
     &              trim(models(iroms)%ExportField(i)%short_name),      &
     &              trim(models(iroms)%ExportField(i)%standard_name),   &
     &              models(iroms)%ExportField(i)%gtype,                 &
     &              models(iroms)%ExportField(i)%itype,                 &
     &              models(iroms)%ExportField(i)%connected,             &
     &              models(iroms)%ExportField(i)%debug_write,           &
     &              models(iroms)%ExportField(i)%add_offset,            &
     &              models(iroms)%ExportField(i)%scale_factor
          END DO
        END IF
        WRITE (cplout,100)
      END IF
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '<== Exiting  ROMS_Create',             &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
!
  10  FORMAT (/,' ROMS_CREATE - Unable to create YAML object for',      &
     &        ' ROMS/CMEPS configuration metadata file: ',/,15x,a,/,    &
     &        15x,'Default file is located in source directory.')
  20  FORMAT (/," ROMS_CREATE - Unable to find key: '",a,"'",           &
     &        ' ROMS/CMEPS configuration metadata file: ',/,15x,a,/,    &
     &        /,15x,'YAML file: ',a)
  30  FORMAT (/,' ROMS_CREATE - cannot find metadata for',              &
     &        1x,a,'''',a,'''.',/,15x,                                  &
     &        'Add entry to metadata file: ',a)
  40  FORMAT (80('-'),/,                                                &
     &        ' Earth System Models Coupling: ESMF/NUOPC Library,',     &
     &        ' Version ',a,/,31x,a,/,                                  &
     &        80('-'),                                                  &
     &        /,1x,'GIT Root URL     : ',a,                             &
     &        /,1x,'GIT Revision     : ',a,                             &
     &        /,1x,'Operating System : ',a,                             &
     &        /,1x,'CPU Hardware     : ',a,                             &
     &        /,1x,'Compiler System  : ',a,                             &
     &        /,1x,'Compiler Command : ',a,                             &
     &        /,1x,'Compiler Flags   : ',a,                             &
     &        /,1x,'MPI Communicator : ',i0,2x,'PET size = ',i0,        &
     &        /,80('-'),/)
  50  FORMAT (1x,a,a)
  60  FORMAT (1x,a,i0)
  70  FORMAT (1x,a,i0,a)
  80  FORMAT (/,a,/, 27('='),/,/, 'Short Name',                         &
     &        t15,'Standard Name', t74,'G', t77,'R', t80,'C', t83,'W',  &
     &        t87,'add_offset', t99,'scale_factor',/, 111('-'))
  90  FORMAT (a, t15,a, t74,i1, t77,i1, t80,l1, t83,l1,                 &
     &        t86,1p,e12.5, t100,1p,e12.5)
 100  FORMAT (/,' G: Grid cell location,     1=Center,',                &
     &                                     ' 2=Corner,',                &
     &                                     ' 3=U-point,',               &
     &                                     ' 4=V-point',                &
     &        /,' R: Regridding method,      1=bilin,',                 &
     &                                     ' 2=patch,',                 &
     &                                     ' 3=consD,',                 &
     &                                     ' 4=consF,',                 &
     &                                     ' 5=redist,',                &
     &                                     ' 6=nStoD,',                 &
     &                                     ' 7=nStoD-consD,',           &
     &                                     ' 8=nStoD-consF',            &
     &        /,' C: Connected to coupler,   F=derived from other,',    &
     &                                     ' T=exchanged/regridded',    &
     &        /,' W: Field write to NetCDF,  F=false, T=true',          &
     &                                     ' (used if DebugLevel > 2)'/)
!
      RETURN
      END SUBROUTINE roms_create
!
      SUBROUTINE roms_setinitializep1 (model,                           &
     &                                 ImportState, ExportState,        &
     &                                 clock, rc)
!
!=======================================================================
!                                                                      !
!  ROMS component Phase 1 initialization: sets import and export       !
!  fields long and short names into its respective state.              !
!                                                                      !
!=======================================================================
!
      USE mod_parallel, ONLY : master
!
!  Imported variable declarations.
!
      integer, intent(out) :: rc
!
      TYPE (esmf_gridcomp) :: model
      TYPE (esmf_state)    :: importstate
      TYPE (esmf_state)    :: exportstate
      TYPE (esmf_clock)    :: clock
!
!  Local variable declarations.
!
      logical :: masterpet, ispresent, isset
!
      integer :: i
      integer :: ng = 1
      integer :: mycomm, petcount, localpet
!
      TYPE (couplingfield), allocatable :: romsexport(:), romsimport(:)
      TYPE (esmf_vm)                    :: vm
      TYPE (yaml_tree)                  :: yml
!
# ifdef ADD_NESTED_STATE
      character (len=100) :: coupledset, statelabel
# endif
      character (len=240) :: standardname, shortname
      character (len=240) :: cfgvalue
      character (len=160) :: message
!
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", ROMS_SetInitializeP1"
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '==> Entering ROMS_SetInitializeP1',    &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  Querry the Virtual Machine (VM) parallel environmemt for the MPI
!  current node rank.
!-----------------------------------------------------------------------
!
      CALL esmf_gridcompget (model,                                     &
     &                       vm=vm,                                     &
     &                       rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      CALL esmf_vmget (vm,                                              &
     &                 localpet=localpet,                               &
     &                 petcount=petcount,                               &
     &                 mpicommunicator=mycomm,                          &
     &                 rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
      masterpet=localpet.eq.0
      petrank=localpet
!
!-----------------------------------------------------------------------
!  Set ROMS standard ouput unit and file
!-----------------------------------------------------------------------
!
!  Sets the ROMS standard output unit to write verbose execution info.
!  Notice that the default standard out unit in Fortran is 6.
!
!  In some applications like coupling or disjointed mpi-communications,
!  it is advantageous to write standard output to a specific filename
!  instead of the default Fortran standard output unit 6. If that is
!  the case, it opens such formatted file for writing.
!
      IF (set_stdoutunit) THEN
        master=masterpet
        stdout=stdout_unit(masterpet)
        set_stdoutunit=.false.
      END IF
!
!-----------------------------------------------------------------------
!  Open standard output unit for ROMS cap information and messages.
!-----------------------------------------------------------------------
!
      OPEN (cplout, file=trim(couplerlog), form='formatted',            &
     &      status='replace')
!
!-----------------------------------------------------------------------
!  Query driver for attributes
!-----------------------------------------------------------------------
!
!  Get ROMS coupling configuration YAML filename.
!
      CALL nuopc_compattributeget (model,                               &
     &                             name='CouplingConfig',               &
     &                             value=cfgvalue,                      &
     &                             ispresent=ispresent,                 &
     &                             isset=isset,                         &
     &                             rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      IF (ispresent.and.isset) THEN
        cplname= trim(cfgvalue)
        message='CouplingConfig = '//trim(cplname)
        CALL esmf_logwrite (trim(message), esmf_logmsg_info)
      ELSE
        message='CouplingConfig needs to be provided: '//               &
     &          'please check the top level ESMF config file.'
        CALL esmf_logseterror (esmf_failure, rctoreturn=rc,             &
     &                         msg=trim(message))
        RETURN
      END IF
!
!  Get 'scalar_field' parameters used by cmeps to check exchanged
!  fields.
!
      CALL nuopc_compattributeget (model,                               &
     &                             name='ScalarFieldName',              &
     &                             value=cfgvalue,                      &
     &                             ispresent=ispresent,                 &
     &                             isset=isset,                         &
     &                             rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      IF (ispresent.and.isset) THEN
        READ (cfgvalue,*) scalarfieldname
      ELSE
        scalarfieldname='cpl_scalars'
      END IF
      WRITE (message, '(a)') 'ScalarFieldName = '//                     &
     &                       trim(scalarfieldname)
      CALL esmf_logwrite(trim(message), esmf_logmsg_info)
!
      CALL nuopc_compattributeget(model,                                &
     &                            name='ScalarFieldCount',              &
     &                            value=cfgvalue,                       &
     &                            ispresent=ispresent,                  &
     &                            isset=isset,                          &
     &                            rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      IF (ispresent.and.isset) THEN
        READ (cfgvalue,*) scalarfieldcount
      ELSE
        scalarfieldcount=0
      END IF
      WRITE(message, '(a,i0)') 'ScalarFieldCount = ',                   &
     &                         scalarfieldcount
      CALL esmf_logwrite(trim(message), esmf_logmsg_info)
!
      CALL nuopc_compattributeget(model,                                &
     &                            name='ScalarFieldIdxGridNX',          &
     &                            value=cfgvalue,                       &
     &                            ispresent=ispresent,                  &
     &                            isset=isset,                          &
     &                            rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      IF (ispresent.and.isset) THEN
        READ(cfgvalue,*) scalarfieldidxgridnx
      ELSE
        scalarfieldidxgridnx = 0
      END IF
      WRITE(message, '(a,i0)') 'ScalarFieldIdxGridNX = ',               &
     &                         scalarfieldidxgridnx
      CALL esmf_logwrite (trim(message), esmf_logmsg_info)
!
      CALL nuopc_compattributeget(model,                                &
     &                            name='ScalarFieldIdxGridNY',          &
     &                            value=cfgvalue,                       &
     &                            ispresent=ispresent,                  &
     &                            isset=isset,                          &
     &                            rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      IF (ispresent.and.isset) THEN
        READ (cfgvalue,*) scalarfieldidxgridny
      ELSE
        scalarfieldidxgridny=0
      END IF
      WRITE (message, '(a,i0)') 'ScalarFieldIdxGridNY = ',              &
     &                          scalarfieldidxgridny
      CALL esmf_logwrite(trim(message), esmf_logmsg_info)
!
!-----------------------------------------------------------------------
!  Create, allocate, and populate module structures. The export and
!  import fields metadata are read from input YAML configuration file.
!-----------------------------------------------------------------------
!
      CALL roms_create (localpet, petcount, mycomm, rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Set ROMS Import State metadata.
!-----------------------------------------------------------------------
 
# ifdef ADD_NESTED_STATE
!
!  Add ROMS Import state. If nesting, each grid has its own import
!  state.
!
      importing : IF (nimport(iroms).gt.0) THEN
        DO ng=1,models(iroms)%Ngrids
          IF (any(coupled(iroms)%LinkedGrid(ng,:))) THEN
            coupledset=trim(coupled(iroms)%SetLabel(ng))
            statelabel=trim(coupled(iroms)%ImpLabel(ng))
            CALL nuopc_addnestedstate (importstate,                     &
     &                                 cplset=trim(coupledset),         &
     &                                 nestedstatename=trim(statelabel),&
     &                                 nestedstate=models(iroms)%       &
     &                                                 importstate(ng), &
                                       rc=rc)
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
            IF (localpet.eq.0) THEN
              WRITE (cplout,10) 'ROMS adding Import Nested State: ',    &
     &                          trim(statelabel), ng
            END IF
!
!  Add fields import state.
!
            DO i=1,nimport(iroms)
              standardname=models(iroms)%ImportField(i)%standard_name
              shortname   =models(iroms)%ImportField(i)%short_name
              IF (localpet.eq.0) THEN
                WRITE (cplout,20) 'Advertising Import Field: ',         &
     &                            trim(shortname), trim(standardname)
              END IF
              CALL nuopc_advertise (models(iroms)%ImportState(ng),      &
     &                              standardname=trim(standardname),    &
     &                              name=trim(shortname),               &
     &                              rc=rc)
              IF (esmf_logfounderror(rctocheck=rc,                      &
     &                               msg=esmf_logerr_passthru,          &
     &                               line=__line__,                     &
     &                               file=myfile)) THEN
                RETURN
              END IF
 
#  ifdef LONGWAVE_OUT
!
              IF (trim(shortname).eq.'LWrad') THEN
                rc=esmf_rc_not_valid
                IF (localpet.eq.0) THEN
                  WRITE (cplout,30) trim(shortname), 'LONGWAVE_OUT',    &
     &                           'downward longwave radiation: dLWrad', &
     &                           'LONGWAVE_OUT'
                END IF
                IF (esmf_logfounderror(rctocheck=rc,                    &
     &                                 msg=esmf_logerr_passthru,        &
     &                                 line=__line__,                   &
     &                                 file=myfile)) THEN
                  RETURN
                END IF
              END IF
#  endif
            END DO
          END IF
        END DO
      END IF importing
# else
!
!  Add fields to ROMS Import state.  Coupled NestedStates are not
!  supported in cdeps/cmeps.
!
      importing : IF (nimport(iroms).gt.0) THEN
        ng=linked_grid
        models(iroms)%ImportState(ng)=importstate
!
        IF (localpet.eq.0) THEN
          WRITE (cplout,10) 'ROMS Import STATE: ', ng
        END IF
!
        DO i=1,nimport(iroms)
          standardname=models(iroms)%ImportField(i)%standard_name
          shortname   =models(iroms)%ImportField(i)%short_name
          IF (localpet.eq.0) THEN
            WRITE (cplout,20) 'Advertising Import Field: ',             &
     &                        trim(shortname), trim(standardname)
          END IF
          CALL nuopc_advertise (models(iroms)%ImportState(ng),          &
     &                          standardname=trim(standardname),        &
     &                          name=trim(shortname),                   &
     &                          rc=rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
 
#  ifdef LONGWAVE_OUT
!
          IF (trim(shortname).eq.'LWrad') THEN
            rc=esmf_rc_not_valid
            IF (localpet.eq.0) THEN
              WRITE (cplout,30) trim(shortname), 'LONGWAVE_OUT',        &
     &                          'downward longwave radiation: dLWrad',  &
     &                          'LONGWAVE_OUT'
            END IF
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
          END IF
#  endif
        END DO
      END IF importing
# endif
!
!-----------------------------------------------------------------------
!  Set ROMS Export State metadata.
!-----------------------------------------------------------------------
 
# ifdef ADD_NESTED_STATE
!
!  Add ROMS Export state. If nesting, each grid has its own export
!  state.
!
      exporting : IF (nexport(iroms).gt.0) THEN
        DO ng=1,models(iroms)%Ngrids
          IF (any(coupled(iroms)%LinkedGrid(ng,:))) THEN
            coupledset=trim(coupled(iroms)%SetLabel(ng))
            statelabel=trim(coupled(iroms)%ExpLabel(ng))
            CALL nuopc_addnestedstate (exportstate,                     &
     &                                 cplset=trim(coupledset),         &
     &                                 nestedstatename=trim(statelabel),&
     &                                 nestedstate=models(iroms)%       &
     &                                                 exportstate(ng), &
                                       rc=rc)
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
            IF (localpet.eq.0) THEN
              WRITE (cplout,10) 'ROMS adding Export Nested State: ',    &
     &                          trim(statelabel), ng
            END IF
!
!  Add fields to export state.
!
            DO i=1,nexport(iroms)
              standardname=models(iroms)%ExportField(i)%standard_name
              shortname   =models(iroms)%ExportField(i)%short_name
              IF (localpet.eq.0) THEN
                WRITE (cplout,20) 'Advertising Export Field: ',         &
     &                            trim(shortname), trim(standardname)
              END IF
              CALL nuopc_advertise (models(iroms)%ExportState(ng),      &
     &                              standardname=trim(standardname),    &
     &                              name=trim(shortname),               &
     &                              rc=rc)
              IF (esmf_logfounderror(rctocheck=rc,                      &
     &                               msg=esmf_logerr_passthru,          &
     &                               line=__line__,                     &
     &                               file=myfile)) THEN
                RETURN
              END IF
            END DO
          END IF
        END DO
      END IF exporting
# else
!
!  Add fields to ROMS Export state.  Coupled NestedStates are not
!  supported in cdeps/cmeps.
!
      exporting : IF (nexport(iroms).gt.0) THEN
        ng=linked_grid
        models(iroms)%ExportState(ng)=exportstate
!
        IF (localpet.eq.0) THEN
          WRITE (cplout,10) 'ROMS Export STATE: ', ng
        END IF
!
        DO i=1,nexport(iroms)
          standardname=models(iroms)%ExportField(i)%standard_name
          shortname   =models(iroms)%ExportField(i)%short_name
          IF (localpet.eq.0) THEN
            WRITE (cplout,20) 'Advertising Export Field: ',             &
     &                        trim(shortname), trim(standardname)
          END IF
          CALL nuopc_advertise (models(iroms)%ExportState(ng),          &
     &                          standardname=trim(standardname),        &
     &                          name=trim(shortname),                   &
     &                          rc=rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
        END DO
      END IF exporting
# endif
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '<== Exiting  ROMS_SetInitializeP1',    &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
!
# ifdef ADD_NESTED_STATE
  10  FORMAT (/,a,a,', ng = ',i0,/,31('='),/)
# else
  10  FORMAT (/,a,'ng = ',i0,/,17('='),/)
# endif
  20  FORMAT (2x,a,"'",a,"'",t45,a)
# ifdef LONGWAVE_OUT
  30  FORMAT (/,' ROMS_SetInitializeP1 - incorrect field to process: ', &
     &        a,/,24x,'when activating option: ',a,/,24x,               &
     &        'use instead ',a,/,24x,'or deactivate option: ',a,/)
# endif
!
      RETURN
      END SUBROUTINE roms_setinitializep1
!
      SUBROUTINE roms_setinitializep2 (model,                           &
     &                                 ImportState, ExportState,        &
     &                                 clock, rc)
!
!=======================================================================
!                                                                      !
!  ROMS component Phase 2 initialization: Initializes ROMS, sets       !
!  component grid, and adds import and export fields to respective     !
!  states.                                                             !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(out) :: rc
!
      TYPE (esmf_gridcomp) :: model
      TYPE (esmf_state)    :: importstate
      TYPE (esmf_state)    :: exportstate
      TYPE (esmf_clock)    :: clock
!
!  Local variable declarations.
!
      logical, save :: first
!
      integer :: lbi, ubi, lbj, ubj
      integer :: mycomm
      integer :: ng, is, localpet, petcount, tile
!
      real (dp) :: driverduration, romsduration
!
      character (len=20) :: timestartstring
      character (len=20) :: timestopstring
 
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", ROMS_SetInitializeP2"
!
      TYPE (esmf_timeinterval) :: runduration, timestep
      TYPE (esmf_time)         :: currtime, starttime, stoptime
      TYPE (esmf_calkind_flag) :: calkindflag
      TYPE (esmf_vm)           :: vm
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '==> Entering ROMS_SetInitializeP2',    &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  Query the Virtual Machine (VM) parallel environmemt for the MPI
!  communicator handle and current node rank.
!-----------------------------------------------------------------------
!
      CALL esmf_gridcompget (model,                                     &
     &                       vm=vm,                                     &
     &                       rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      CALL esmf_vmget (vm,                                              &
     &                 localpet=localpet,                               &
     &                 petcount=petcount,                               &
     &                 mpicommunicator=mycomm,                          &
     &                 rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
      tile=localpet
!
!-----------------------------------------------------------------------
!  Initialize ROMS component.  In nested applications, ROMS kernel will
!  allocate and initialize all grids with a single call to
!  "ROMS_initialize".
!-----------------------------------------------------------------------
!
      first=.true.
      CALL roms_initialize (first, mpicomm=mycomm)
      IF (exit_flag.ne.noerror) THEN
        rc=esmf_rc_obj_init
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
      END IF
 
# ifdef TIME_INTERP
!
!-----------------------------------------------------------------------
!  Create field time interpolation variable attributes NetCDF file. It
!  needs to be done after ROMS initialization since the NetCDF and
!  mpi interface use several variables from ROMS profiling that need
!  to be allocated.
!-----------------------------------------------------------------------
!
      IF (petlayoutoption.eq.'CONCURRENT') THEN
        CALL def_fieldatt (vm, rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
      END IF
# endif
!
!-----------------------------------------------------------------------
!  Query driver clock.
!-----------------------------------------------------------------------
!
      IF (models(iroms)%IsActive) THEN
        CALL nuopc_modelget (model,                                     &
     &                       driverclock=clockinfo(idriver)%Clock,      &
                             rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
!
        CALL esmf_clockget (clockinfo(idriver)%Clock,                   &
     &                      starttime=starttime,                        &
     &                      stoptime=stoptime,                          &
     &                      currtime=currtime,                          &
     &                      timestep=timestep,                          &
     &                      calkindflag=calkindflag,                    &
     &                      runduration=runduration,                    &
     &                      rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
!
        clockinfo(idriver)%TimeStep = timestep
        clockinfo(idriver)%CurrentTime = currtime
        clockinfo(idriver)%StartTime = starttime
        clockinfo(idriver)%StopTime = stoptime
!
        IF (calkindflag == esmf_calkind_gregorian) THEN
          clockinfo(idriver)%CalendarString = 'gregorian'
        ELSE IF (calkindflag == esmf_calkind_360day) THEN
          clockinfo(idriver)%CalendarString = '360_day'
        END IF
!
        CALL esmf_timeget (clockinfo(idriver)%StartTime,                &
     &                     s_r8=clockinfo(idriver)%Time_Start,          &
     &                     timestring=timestartstring,                  &
     &                     rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
!
        is=index(timestartstring, 'T')
        IF (is.gt.0) timestartstring(is:is)=' '
        clockinfo(idriver)%Time_StartString=trim(timestartstring)
!
        CALL esmf_timeget (clockinfo(idriver)%StopTime,                 &
     &                     s_r8=clockinfo(idriver)%Time_Stop,           &
     &                     timestring=timestopstring,                   &
     &                     rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
!
        is=index(timestopstring, 'T')
        IF (is.gt.0) timestopstring(is:is)=' '
        clockinfo(idriver)%Time_StopString=trim(timestopstring)
!
# ifdef REGRESS_STARTCLOCK
        CALL esmf_timeintervalget (runduration-timestep,                &
     &                             s_r8=driverduration,                 &
     &                             rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
# else
        CALL esmf_timeintervalget (runduration,                         &
     &                             s_r8=driverduration,                 &
     &                             rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
# endif
!
        DO ng=1,models(iroms)%Ngrids
          IF (any(coupled(iroms)%LinkedGrid(ng,:))) THEN
            romsduration=(ntend(ng)-ntfirst(ng)+1)*dt(ng)
            IF (romsduration.ne.driverduration) THEN
              IF (localpet.eq.0) THEN
                WRITE (cplout,10) romsduration, driverduration,         &
     &                            trim(inpname(iroms))
              END IF
              rc=esmf_rc_not_valid
              RETURN
            END IF
          END IF
        END DO
      END IF
!
!  Report Clock:
!
      IF (localpet.eq.0) THEN
        WRITE (cplout,20) timestartstring, timestopstring,              &
     &                    int(driverduration), int(romsduration)
      END IF
!
!-----------------------------------------------------------------------
!  Set-up grid and load coordinate data.
!-----------------------------------------------------------------------
!
      DO ng=1,models(iroms)%Ngrids
        IF (any(coupled(iroms)%LinkedGrid(ng,:))) THEN
          CALL roms_setgridarrays (ng, tile, model, rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
        END IF
      END DO
!
!-----------------------------------------------------------------------
!  Set-up fields and register to import/export states.
!-----------------------------------------------------------------------
!
      DO ng=1,models(iroms)%Ngrids
        IF (any(coupled(iroms)%LinkedGrid(ng,:))) THEN
          CALL roms_setstates (ng, tile, model, rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
        END IF
      END DO
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '<== Exiting  ROMS_SetInitializeP2',    &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
!
  10  FORMAT (/,' ROMS_SetInitializeP2 - inconsitent configuration ',   &
     &        'run duration',/,24x,                                     &
     &        'ROMS Duration     = ',f20.2,' seconds',/,24x,            &
     &        'Coupling Duration = ',f20.2,' seconds',/,24x,            &
     &        'Check paramenter NTIMES in ''',a,'''',a)
  20  FORMAT (/,'Coupling Clock: ROMS_SetInitializeP2',/,15('='),/,     &
     &        /,2x,'DRIVER Starting Date = ',a,                         &
     &        /,2x,'DRIVER Ending   Date = ',a,                         &
     &        /,2x,'DRIVER Duration (s)  = ',i0,                        &
     &        /,2x,'ROMS   Duration (s)  = ',i0)
!
      RETURN
      END SUBROUTINE roms_setinitializep2
!
      SUBROUTINE roms_datainit (model, rc)
!
!=======================================================================
!                                                                      !
!  Exports ROMS component fields during initialization or restart.     !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(out) :: rc
!
      TYPE (esmf_gridcomp) :: model
!
!  Local variable declarations.
!
      integer :: ng
!
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", ROMS_DataInit"
!
      TYPE (esmf_time)  :: currenttime
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '==> Entering ROMS_DataInit',           &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  Get gridded component clock current time.
!-----------------------------------------------------------------------
!
      CALL esmf_clockget (clockinfo(iroms)%Clock,                       &
     &                    currtime=currenttime,                         &
     &                    rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Export initialization or restart fields.
!-----------------------------------------------------------------------
!
      IF (nexport(iroms).gt.0) THEN
        DO ng=1,models(iroms)%Ngrids
          IF (any(coupled(iroms)%LinkedGrid(ng,:))) THEN
            CALL roms_export (ng, model, rc)
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
          END IF
        END DO
      END IF
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '<== Exiting  ROMS_DataInit',           &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
!
      RETURN
      END SUBROUTINE roms_datainit
!
      SUBROUTINE roms_setclock (model, rc)
!
!=======================================================================
!                                                                      !
!  Sets ROMS component date calendar, start and stop time, and         !
!  coupling interval.  At initilization, the variable "tdays" is       !
!  the initial time meassured in fractional days since the reference   !
!  time.                                                               !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(out) :: rc
!
      TYPE (esmf_gridcomp) :: model
!
!  Local variable declarations.
!
      integer :: ng
      integer :: ref_year,   start_year,   stop_year
      integer :: ref_month,  start_month,  stop_month
      integer :: ref_day,    start_day,    stop_day
      integer :: ref_hour,   start_hour,   stop_hour
      integer :: ref_minute, start_minute, stop_minute
      integer :: ref_second, start_second, stop_second
      integer :: petcount, localpet
      integer :: timefrac
!
      real(dp) :: mystarttime, mystoptime
!
      character (len= 22) :: calendar
      character (len= 22) :: starttimestring, stoptimestring
      character (len=160) :: message
 
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", ROMS_SetClock"
!
      TYPE (esmf_calkind_flag) :: caltype
      TYPE (esmf_clock)        :: clock
      TYPE (esmf_vm)           :: vm
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '==> Entering ROMS_SetClock',           &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  Querry the Virtual Machine (VM) parallel environmemt for the MPI
!  communicator handle and current node rank.
!-----------------------------------------------------------------------
!
      CALL esmf_gridcompget (model,                                     &
     &                       localpet=localpet,                         &
     &                       petcount=petcount,                         &
     &                       vm=vm,                                     &
     &                       rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Create ROMS component clock.
!-----------------------------------------------------------------------
!
!  Set ROMS time reference: model time is meassured as seconds since
!  reference time.  ESMF does not support the Proleptic Gregorian
!  Calendar that extends backward the dates preceeding 15 October 1582
!  which always have a year length of 365.2425 days.
!
!  Using driver provided calendar since UFS Weather Model does not
!  support Proleptic Gregorian Calendar.
!
      ref_year  =rclock%year
      ref_month =rclock%month
      ref_day   =rclock%day
      ref_hour  =rclock%hour
      ref_minute=rclock%minutes
      ref_second=rclock%seconds
      calendar  =trim(clockinfo(idriver)%CalendarString)
      clockinfo(iroms)%CalendarString = trim(calendar)
!
      IF (clockinfo(iroms)%CalendarString == '360_day') THEN
        caltype=esmf_calkind_360day
      ELSE
        caltype=esmf_calkind_gregorian
      END IF
!
      clockinfo(iroms)%Calendar=esmf_calendarcreate(caltype,            &
     &                                              name=trim(calendar),&
     &                                              rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Set reference time.
!
      CALL esmf_timeset (clockinfo(iroms)%ReferenceTime,                &
     &                   yy=ref_year,                                   &
     &                   mm=ref_month,                                  &
     &                   dd=ref_day,                                    &
     &                   h =ref_hour,                                   &
     &                   m =ref_minute,                                 &
     &                   s =ref_second,                                 &
     &                   calendar=clockinfo(iroms)%Calendar,            &
     &                   rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
 
# ifdef REGRESS_STARTCLOCK
!
!  Set start time, use the minimum value of all nested grids. Notice
!  that a coupling interval is substracted since the driver clock was
!  regressed by that amount to properly initialize all ESM components.
!
      mystarttime=minval(tdays)-clockinfo(iroms)%Time_Step/86400.0_dp
# else
!
!  Set start time, use the minimum value of all nested grids.
!
      mystarttime=minval(tdays)
# endif
!
      clockinfo(iroms)%Time_Start=mystarttime*86400.0_dp
      CALL caldate (mystarttime,                                        &
     &              yy_i=start_year,                                    &
     &              mm_i=start_month,                                   &
     &              dd_i=start_day,                                     &
     &              h_i =start_hour,                                    &
     &              m_i =start_minute,                                  &
     &              s_i =start_second)
      CALL time_string (clockinfo(iroms)%Time_Start,                    &
     &                  clockinfo(iroms)%Time_StartString)
!
      CALL esmf_timeset (clockinfo(iroms)%StartTime,                    &
     &                   yy=start_year,                                 &
     &                   mm=start_month,                                &
     &                   dd=start_day,                                  &
     &                   h =start_hour,                                 &
     &                   m =start_minute,                               &
     &                   s =start_second,                               &
     &                   ms=0,                                          &
     &                   calendar=clockinfo(iroms)%Calendar,            &
     &                   rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Set stop time, use the maximum value of all nested grids.
!
      mystoptime=0.0_dp
      DO ng=1,models(iroms)%Ngrids
        IF (any(coupled(iroms)%LinkedGrid(ng,:))) THEN
          mystoptime=max(mystoptime,                                    &
     &                   tdays(ng)+(real(ntimes(ng),dp)*dt(ng))*sec2day)
        END IF
      END DO
      clockinfo(iroms)%Time_Stop=mystoptime*86400.0_dp
      CALL caldate (mystoptime,                                         &
     &              yy_i=stop_year,                                     &
     &              mm_i=stop_month,                                    &
     &              dd_i=stop_day,                                      &
     &              h_i =stop_hour,                                     &
     &              m_i =stop_minute,                                   &
     &              s_i =stop_second)
      CALL time_string (clockinfo(iroms)%Time_Stop,                     &
     &                  clockinfo(iroms)%Time_StopString)
!
      CALL esmf_timeset (clockinfo(iroms)%StopTime,                     &
     &                   yy=stop_year,                                  &
     &                   mm=stop_month,                                 &
     &                   dd=stop_day,                                   &
     &                   h =stop_hour,                                  &
     &                   m =stop_minute,                                &
     &                   s =stop_second,                                &
     &                   calendar=clockinfo(iroms)%Calendar,            &
     &                   rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Modify component clock time step.
!-----------------------------------------------------------------------
!
      timefrac=0
      DO ng=1,models(iroms)%Ngrids
        IF (any(coupled(iroms)%LinkedGrid(ng,:))) THEN
          timefrac=max(timefrac,                                        &
     &                 maxval(models(iroms)%TimeFrac(ng,:),             &
     &                        mask=models(:)%IsActive))
        END IF
      END DO
      IF (timefrac.lt.1) THEN              ! needs to be 1 or greater
        rc=esmf_rc_not_set                 ! cannot be 0
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
      END IF
!
      clockinfo(iroms)%TimeStep=clockinfo(idriver)%TimeStep/timefrac
!
!-----------------------------------------------------------------------
!  Create ROMS component clock.
!-----------------------------------------------------------------------
!
      clockinfo(iroms)%Name='ROMS_clock'
      clock=esmf_clockcreate(clockinfo(iroms)%TimeStep,                 &
     &                       clockinfo(iroms)%StartTime,                &
     &                       stoptime =clockinfo(iroms)%StopTime,       &
     &                       reftime  =clockinfo(iroms)%ReferenceTime,  &
     &                       name     =trim(clockinfo(iroms)%Name),     &
     &                       rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
      clockinfo(iroms)%Clock=clock
!
!  Set ROMS component clock.
!
      CALL esmf_gridcompset (model,                                     &
     &                       clock=clockinfo(iroms)%Clock,              &
     &                       rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Get current time.
!
      CALL esmf_clockget (clockinfo(iroms)%Clock,                       &
     &                    currtime=clockinfo(iroms)%CurrentTime,        &
     &                    rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Compare driver time against ROMS component time.
!-----------------------------------------------------------------------
!
      IF (clockinfo(idriver)%Restarted) THEN
        starttimestring=trim(clockinfo(idriver)%Time_RestartString)
      ELSE
        starttimestring=trim(clockinfo(idriver)%Time_StartString)
      END IF
!
!  Report start and stop time clocks.
!
      IF (localpet.eq.0) THEN
        WRITE (cplout,'(/)')
        WRITE (cplout,10) 'DRIVER Calendar:    ',                       &
     &                    trim(clockinfo(idriver)%CalendarString),      &
     &                    'DRIVER Start Clock: ',                       &
     &                    trim(clockinfo(idriver)%Time_StartString),    &
     &                    'DRIVER Stop  Clock: ',                       &
     &                    trim(clockinfo(idriver)%Time_StopString)
!
        WRITE (cplout,10) 'ROMS Calendar:      ',                       &
     &                    trim(clockinfo(iroms)%CalendarString),        &
     &                    'ROMS Start Clock:   ',                       &
     &                    trim(clockinfo(iroms)%Time_StartString),      &
     &                    'ROMS Stop  Clock:   ',                       &
     &                    trim(clockinfo(iroms)%Time_StopString)
      END IF
!
!  Compare Driver and ROMS clocks.
!
      IF (clockinfo(iroms)%Time_StartString(1:19).ne.                   &
     &    starttimestring(1:19)) THEN
        IF (localpet.eq.0) THEN
          WRITE (cplout,20) 'ROMS   Start Time: ',                      &
     &                      clockinfo(iroms)%Time_StartString(1:19),    &
     &                      'Driver Start Time: ',                      &
     &                      trim(starttimestring),                      &
     &                      '                   are not equal!'
        END IF
        message='Driver and ROMS start times do not match: '//          &
     &          'please check the config files.'
        CALL esmf_logseterror (esmf_failure, rctoreturn=rc,             &
     &                         msg=trim(message))
        RETURN
      END IF
!
      IF (clockinfo(iroms  )%Time_StopString(1:19).ne.                  &
     &    clockinfo(idriver)%Time_StopString(1:19)) THEN
        IF (localpet.eq.0) THEN
          WRITE (cplout,20) 'ROMS   Stop Time: ',                       &
     &                      clockinfo(iroms  )%Time_StopString(1:19),   &
     &                      'Driver Stop Time: ',                       &
     &                      trim(clockinfo(idriver)%Time_StopString),   &
     &                      '                   are not equal!'
        END IF
        message='Driver and ROMS stop times do not match: '//           &
     &          'please check the config files.'
        CALL esmf_logseterror (esmf_failure, rctoreturn=rc,             &
     &                         msg=trim(message))
        RETURN
      END IF
!
      IF (trim(clockinfo(iroms  )%CalendarString).ne.                   &
     &    trim(clockinfo(idriver)%CalendarString)) THEN
        IF (localpet.eq.0) THEN
          WRITE (cplout,20) 'ROMS   Calendar: ',                        &
     &                      trim(clockinfo(iroms  )%CalendarString),    &
     &                      'Driver Calendar: ',                        &
     &                      trim(clockinfo(idriver)%CalendarString),    &
     &                      '                  are not equal!'
        END IF
        message='Driver and ROMS calendars do not match: '//            &
     &          'please check the config files.'
        CALL esmf_logseterror (esmf_failure, rctoreturn=rc,             &
     &                         msg=trim(message))
        RETURN
      END IF
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '<== Exiting  ROMS_SetClock',           &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
!
 10   FORMAT (2x,a,2x,a/,2x,a,2x,a,/,2x,a,2x,a,/)
 20   FORMAT (/,2x,a,a,/,2x,a,a,/,2x,a)
!
      RETURN
      END SUBROUTINE roms_setclock
 
# ifdef ESM_SETRUNCLOCK
!
      SUBROUTINE roms_setrunclock (model, rc)
!
!=======================================================================
!                                                                      !
!  Sets ROMS run clock manually to avoid getting zero time stamps at   !
!  the first regridding call.                                          !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(out) :: rc
!
      TYPE (esmf_gridcomp) :: model
!
!  Local variable declarations.
!
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", ROMS_SetRunClock"
!
      TYPE (esmf_clock) :: driverclock, modelclock
      TYPE (esmf_time)  :: currtime
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '==> Entering ROMS_SetRunClock',        &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  Set ROMS run clock manually.
!-----------------------------------------------------------------------
!
!  Inquire driver and model clock.
!
      CALL nuopc_modelget (model,                                       &
     &                     driverclock=driverclock,                     &
     &                     modelclock=modelclock,                       &
     &                     rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Set model clock to have the current start time as the driver clock.
!
      CALL esmf_clockget (driverclock,                                  &
     &                    currtime=currtime,                            &
     &                    rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      CALL esmf_clockset (modelclock,                                   &
     &                    currtime=currtime,                            &
     &                    rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Check and set the component clock against the driver clock.
!
      CALL nuopc_compchecksetclock (model,                              &
     &                              driverclock,                        &
     &                              rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '<== Exiting  ROMS_SetRunClock',        &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
!
      RETURN
      END SUBROUTINE roms_setrunclock
# endif
!
      SUBROUTINE roms_checkimport (model, rc)
!
!=======================================================================
!                                                                      !
!  Checks if ROMS component import field is at the correct time.       !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(out) :: rc
!
      TYPE (esmf_gridcomp) :: model
!
!  Local variable declarations.
!
      logical :: isvalid, atcorrecttime
!
      integer :: importcount, i, is, localpet, ng
!
      real (dp) :: tcurrentinseconds
!
      character (len=22) :: drivertimestring, fieldtimestring
 
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", ROMS_CheckImport"
!
      character (ESMF_MAXSTR) :: string, fieldname
      character (ESMF_MAXSTR), allocatable :: importnamelist(:)
!
      TYPE (esmf_clock)        :: driverclock
      TYPE (esmf_field)        :: field
      TYPE (esmf_time)         :: starttime, currenttime
      TYPE (esmf_time)         :: drivertime, fieldtime
      TYPE (esmf_timeinterval) :: timestep
      TYPE (esmf_vm)           :: vm
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '==> Entering ROMS_CheckImport',        &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  Query component.
!-----------------------------------------------------------------------
!
      CALL nuopc_modelget (model,                                       &
     &                     driverclock=driverclock,                     &
     &                     rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      CALL esmf_gridcompget (model,                                     &
     &                       localpet=localpet,                         &
     &                       vm=vm,                                     &
     &                       rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Get the start time and current time from driver clock.
!-----------------------------------------------------------------------
!
      CALL esmf_clockget (driverclock,                                  &
     &                    timestep=timestep,                            &
     &                    starttime=starttime,                          &
     &                    currtime=drivertime,                          &
     &                    rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Adjust driver clock for semi-implicit coupling.
 
      IF (couplingtype.eq.1) THEN
        currenttime=drivertime                  ! explicit coupling
      ELSE
        currenttime=drivertime+timestep         ! semi-implicit coupling
      END IF
!
      CALL esmf_timeget (currenttime,                                   &
     &                   s_r8=tcurrentinseconds,                        &
     &                   timestringisofrac=drivertimestring,            &
     &                   rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
      is=index(drivertimestring, 'T')                 ! remove 'T' in
      IF (is.gt.0) drivertimestring(is:is)=' '        ! ISO 8601 format
!
!-----------------------------------------------------------------------
!  Get list of import fields.
!-----------------------------------------------------------------------
!
      IF (nimport(iroms).gt.0) THEN
        nested_loop : DO ng=1,models(iroms)%Ngrids
          IF (any(coupled(iroms)%LinkedGrid(ng,:))) THEN
            CALL esmf_stateget (models(iroms)%ImportState(ng),          &
     &                          itemcount=importcount,                  &
     &                          rc=rc)
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
!
            IF (.not.allocated(importnamelist)) THEN
              allocate ( importnamelist(importcount) )
            END IF
!
            CALL esmf_stateget (models(iroms)%ImportState(ng),          &
     &                          itemnamelist=importnamelist,            &
     &                          rc=rc)
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
!
!-----------------------------------------------------------------------
!  Only check fields in the ImportState object.
!-----------------------------------------------------------------------
!
            field_loop : DO i=1,importcount
              fieldname=trim(importnamelist(i))
              CALL esmf_stateget (models(iroms)%ImportState(ng),        &
     &                            itemname=trim(fieldname),             &
     &                            field=field,                          &
     &                            rc=rc)
              IF (esmf_logfounderror(rctocheck=rc,                      &
     &                               msg=esmf_logerr_passthru,          &
     &                               line=__line__,                     &
     &                               file=myfile)) THEN
                RETURN
              END IF
!
!  If debugging, report field timestamp.
!
              IF (debuglevel.gt.1) THEN
                CALL nuopc_gettimestamp (field,                         &
     &                                   isvalid = isvalid,             &
     &                                   time = fieldtime,              &
     &                                   rc = rc)
                IF (esmf_logfounderror(rctocheck=rc,                    &
     &                                 msg=esmf_logerr_passthru,        &
     &                                 line=__line__,                   &
     &                                 file=myfile)) THEN
                  RETURN
                END IF
!
                IF (isvalid) THEN
                  CALL esmf_timeget (fieldtime,                         &
     &                             timestringisofrac = fieldtimestring, &
     &                               rc=rc)
                  IF (esmf_logfounderror(rctocheck=rc,                  &
     &                                   msg=esmf_logerr_passthru,      &
     &                                   line=__line__,                 &
     &                                   file=myfile)) THEN
                    RETURN
                  END IF
                  is=index(fieldtimestring, 'T')            ! remove 'T'
                  IF (is.gt.0) fieldtimestring(is:is)=' '
!
                  IF (localpet.eq.0) THEN
                    WRITE (cplout,10) trim(fieldname),                  &
     &                                trim(fieldtimestring),            &
     &                                trim(drivertimestring)
                  END IF
                END IF
              END IF
!
!  Check if import field is at the correct time.
!
              string='ROMS_CheckImport - '//trim(fieldname)//' field'
!
              atcorrecttime=nuopc_isattime(field,                       &
     &                                     currenttime,                 &
     &                                     rc=rc)
              IF (esmf_logfounderror(rctocheck=rc,                      &
     &                               msg=esmf_logerr_passthru,          &
     &                               line=__line__,                     &
     &                               file=myfile)) THEN
                RETURN
              END IF
!
              IF (.not.atcorrecttime) THEN
                CALL report_timestamp (field, currenttime,              &
     &                                 localpet, trim(string), rc)
!
                string='NUOPC INCOMPATIBILITY DETECTED: Import '//      &
     &                 'Fields not at correct time'
                CALL esmf_logseterror(esmf_rc_not_valid,                &
     &                                msg=trim(string),                 &
     &                                line=__line__,                    &
     &                                file=myfile,                      &
     &                                rctoreturn=rc)
                RETURN
              END IF
            END DO field_loop
            IF (allocated(importnamelist)) deallocate (importnamelist)
          END IF
        END DO nested_loop
      END IF
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '<== Exiting  ROMS_CheckImport',        &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
!
  10  FORMAT (1x,'ROMS_CheckImport - ',a,':',t32,'TimeStamp = ',a,      &
     &        ',  DriverTime = ',a)
!
      RETURN
      END SUBROUTINE roms_checkimport
!
      SUBROUTINE roms_setgridarrays (ng, tile, model, rc)
!
!=======================================================================
!                                                                      !
!  Sets ROMS component staggered, horizontal grids arrays and          !
!  land/sea mask, if any.                                              !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(in)  :: ng, tile
      integer, intent(out) :: rc
!
      TYPE (esmf_gridcomp), intent(inout) :: model
!
!  Local variable declarations.
!
      integer :: mytile, gtype, i, ivar, j, node
      integer :: istr,  iend,  jstr,  jend
      integer :: istrr, iendr, jstrr, jendr
      integer :: localde, localdecount
      integer :: staggeredgelwidth(2)
      integer :: staggeredgeuwidth(2)
!
      integer, allocatable :: deblocklist(:,:,:)
      integer (i4b), pointer :: ptrm(:,:) => null()     ! land/sea mask
!
      real (dp), pointer :: ptra(:,:) => null()         ! area
      real (dp), pointer :: ptrx(:,:) => null()         ! longitude
      real (dp), pointer :: ptry(:,:) => null()         ! latitude
!
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", ROMS_SetGridArrays"
!
      TYPE (esmf_distgrid)   :: distgrid
      TYPE (esmf_staggerloc) :: staggerloc
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '==> Entering ROMS_SetGridArrays',      &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  Set limits of the grid arrays based on tile decomposition (MPI rank)
!  and nested grid number.
!-----------------------------------------------------------------------
!
      istrr=bounds(ng)%IstrR(tile)   ! Full range I-starting (RHO)
      iendr=bounds(ng)%IendR(tile)   ! Full range I-ending   (RHO)
      jstrr=bounds(ng)%JstrR(tile)   ! Full range J-starting (RHO)
      jendr=bounds(ng)%JendR(tile)   ! Full range J-ending   (RHO)
!
      istr=bounds(ng)%Istr(tile)     ! Full range I-starting (PSI, U)
      iend=bounds(ng)%Iend(tile)     ! Full range I-ending   (PSI)
      jstr=bounds(ng)%Jstr(tile)     ! Full range J-starting (PSI, V)
      jend=bounds(ng)%Jend(tile)     ! Full range J-ending   (PSI)
!
!  Set tiles lower and upper bounds for each decomposition element.
!  In ROMS, the "exclusive region" for each decomposition element or
!  horizontal tile ranges is bounded by (Istr:Iend, Jstr:Jend). Each
!  tiled array is dimensioned as (LBi:UBi, LBj:UBj) which includes
!  halo regions (usually 2 ghost points) and padding when appropriate
!  (total/memory region). All ROMS arrays are horizontally dimensioned
!  with the same bounds regardless if they are variables located at
!  RHO-, PSI-, U-, or V-points. There is no halos at the boundary edges.
!  The physical boundary is a U-points (east/west edges) and V-points
!  (south/north edges). The boundary for RHO-points variables are
!  located at half grid (dx,dy) distance away from the physical boundary
!  at array indices(i=0; i=Lm+1) and (j=0; j=Mm+1).
!
!               --------------------- UBj      ESMF uses a very
!              |                     |         complicated array
!              | Jend __________     |         regions:
!              |     |          |    |
!              |     |          |    |         * interior region
!              |     |          |    |         * exclusive region
!              | Jstr|__________|    |         * computational region
!              |     Istr    Iend    |         * total (memory) region
!              |                     |
!               --------------------- LBj
!               LBi               UBi
!
      IF (.not.allocated(deblocklist)) THEN
        allocate ( deblocklist(2,2,ntilei(ng)*ntilej(ng)) )
      END IF
      DO mytile=0,ntilei(ng)*ntilej(ng)-1
        deblocklist(1,1,mytile+1)=bounds(ng)%Istr(mytile)
        deblocklist(1,2,mytile+1)=bounds(ng)%Iend(mytile)
        deblocklist(2,1,mytile+1)=bounds(ng)%Jstr(mytile)
        deblocklist(2,2,mytile+1)=bounds(ng)%Jend(mytile)
      END DO
!
!-----------------------------------------------------------------------
!  Create ESMF DistGrid object based on model domain decomposition.
!-----------------------------------------------------------------------
!
!  A single Decomposition Element (DE) per Persistent Execution Thread
!  (PET).
!
      distgrid=esmf_distgridcreate(minindex=(/ 1, 1 /),                 &
     &                             maxindex=(/ lm(ng), mm(ng) /),       &
     &                             deblocklist=deblocklist,             &
     &                             rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Report ROMS DistGrid based on model domain decomposition.
!
      IF ((tile.eq.0).and.(debuglevel.gt.0)) THEN
        WRITE (cplout,10) ng, trim(gridtype(icenter))//" Point",        &
     &                    ntilei(ng), ntilej(ng)
        DO mytile=1,ntilei(ng)*ntilej(ng)
          WRITE (cplout,20) mytile-1, deblocklist(1,1,mytile),          &
     &                                deblocklist(1,2,mytile),          &
     &                                deblocklist(2,1,mytile),          &
     &                                deblocklist(2,2,mytile)
        END DO
      END IF
      IF (allocated(deblocklist)) deallocate (deblocklist)
!
!-----------------------------------------------------------------------
!  Set component grid coordinates.
!-----------------------------------------------------------------------
!
!  Define component grid location type: Arakawa C-grid.
!
!    Icenter:  RHO-point, cell center
!    Icorner:  PSI-point, cell corners
!    Iupoint:  U-point,   cell west/east sides
!    Ivpoint:  V-point,   cell south/north sides
!
      IF (.not.allocated(models(iroms)%mesh)) THEN
        allocate ( models(iroms)%mesh(4) )
        models(iroms)%mesh(1)%gtype=icenter
        models(iroms)%mesh(2)%gtype=icorner
        models(iroms)%mesh(3)%gtype=iupoint
        models(iroms)%mesh(4)%gtype=ivpoint
      END IF
!
!  Create ESMF Grid. The array indices are global following ROMS
!  design.
!
      models(iroms)%grid(ng)=esmf_gridcreate(distgrid=distgrid,         &
     &                                   gridedgelwidth=(/2,2/),        &
     &                                   gridedgeuwidth=(/2,2/),        &
     &                                   indexflag=esmf_index_global,   &
     &                                   name=trim(models(iroms)%name), &
     &                                   rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Get number of local decomposition elements (DEs). Usually, a single
!  DE is associated with each Persistent Execution Thread (PETs). Thus,
!  localDEcount=1.
!
      CALL esmf_gridget (models(iroms)%grid(ng),                        &
     &                   localdecount=localdecount,                     &
     &                   rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Mesh coordinates for each variable type.
!
      mesh_loop : DO ivar=1,ubound(models(iroms)%mesh, dim=1)
!
!  Set staggering type, Arakawa C-grid.
!
        SELECT CASE (models(iroms)%mesh(ivar)%gtype)
          CASE (icenter)
            staggerloc=esmf_staggerloc_center
            staggeredgelwidth=(/1,1/)
            staggeredgeuwidth=(/1,1/)
          CASE (icorner)
            staggerloc=esmf_staggerloc_corner
            staggeredgelwidth=(/1,1/)
            staggeredgeuwidth=(/2,2/)
          CASE (iupoint)
            staggerloc=esmf_staggerloc_edge1
            staggeredgelwidth=(/1,1/)
            staggeredgeuwidth=(/2,1/)
          CASE (ivpoint)
            staggerloc=esmf_staggerloc_edge2
            staggeredgelwidth=(/1,1/)
            staggeredgeuwidth=(/1,2/)
        END SELECT
!
!  Allocate coordinate storage associated with staggered grid type.
!  No coordinate values are set yet.
!
        CALL esmf_gridaddcoord (models(iroms)%grid(ng),                 &
     &                          staggerloc=staggerloc,                  &
     &                          staggeredgelwidth=staggeredgelwidth,    &
     &                          staggeredgeuwidth=staggeredgeuwidth,    &
     &                          rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
 
# ifdef MASKING
!
!  Allocate storage for land/sea masking.
!
        CALL esmf_gridadditem (models(iroms)%grid(ng),                  &
     &                         staggerloc=staggerloc,                   &
     &                         itemflag=esmf_griditem_mask,             &
     &                         rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
        models(iroms)%LandValue=0
        models(iroms)%SeaValue=1
# endif
!
!  Allocate storage for grid area.
!
        CALL esmf_gridadditem (models(iroms)%grid(ng),                  &
     &                         staggerloc=staggerloc,                   &
     &                         itemflag=esmf_griditem_area,             &
     &                         rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
!
!  Get pointers and set coordinates for the grid.  Usually, the DO-loop
!  is executed once since localDEcount=1.
!
        de_loop : DO localde=0,localdecount-1
          CALL esmf_gridgetcoord (models(iroms)%grid(ng),               &
     &                            coorddim=1,                           &
     &                            localde=localde,                      &
     &                            staggerloc=staggerloc,                &
     &                            farrayptr=ptrx,                       &
     &                            rc=rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
!
          CALL esmf_gridgetcoord (models(iroms)%grid(ng),               &
     &                            coorddim=2,                           &
     &                            localde=localde,                      &
     &                            staggerloc=staggerloc,                &
     &                            farrayptr=ptry,                       &
     &                            rc=rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
!
          CALL esmf_gridgetitem (models(iroms)%grid(ng),                &
     &                           localde=localde,                       &
     &                           staggerloc=staggerloc,                 &
     &                           itemflag=esmf_griditem_mask,           &
     &                           farrayptr=ptrm,                        &
     &                           rc=rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
!
          CALL esmf_gridgetitem (models(iroms)%grid(ng),                &
     &                           localde=localde,                       &
     &                           staggerloc=staggerloc,                 &
     &                           itemflag=esmf_griditem_area,           &
     &                           farrayptr=ptra,                        &
     &                           rc=rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
!
!  Fill grid pointers.
!
          SELECT CASE (models(iroms)%mesh(ivar)%gtype)
!                                                        U-points
            CASE (icenter)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  ptrx(i,j)=grid(ng)%lonr(i,j)
                  ptry(i,j)=grid(ng)%latr(i,j)
# ifdef MASKING
                  ptrm(i,j)=int(grid(ng)%rmask(i,j))
# else
                  ptrm(i,j)=1
# endif
                  ptra(i,j)=grid(ng)%om_r(i,j)*grid(ng)%on_r(i,j)
                END DO
              END DO
!                                                        PSI-points
            CASE (icorner)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  ptrx(i,j)=grid(ng)%lonp(i,j)
                  ptry(i,j)=grid(ng)%latp(i,j)
# ifdef MASKING
                  ptrm(i,j)=int(grid(ng)%pmask(i,j))
# else
                  ptrm(i,j)=1
# endif
                  ptra(i,j)=grid(ng)%om_p(i,j)*grid(ng)%on_p(i,j)
                END DO
              END DO
!                              Extrapolate PSI-points at bottom edge
!
              IF (tile.lt.ntilei(ng)) THEN
                ptrx(:,jstr-1)=2.0_dp*ptrx(:,jstr)-ptrx(:,jstr+1)
                ptry(:,jstr-1)=2.0_dp*ptry(:,jstr)-ptry(:,jstr+1)
                ptrm(:,jstr-1)=ptrm(:,jstr)
                ptra(:,jstr-1)=ptra(:,jstr)
              END IF
!                              Extrapolate PSI-points at left edge
!
              IF (mod(tile,ntilei(ng)).eq.0) THEN
                ptrx(istr-1,:)=2.0_dp*ptrx(istr,:)-ptrx(istr+1,:)
                ptry(istr-1,:)=2.0_dp*ptry(istr,:)-ptry(istr+1,:)
                ptrm(istr-1,:)=ptrm(istr,:)
                ptra(istr-1,:)=ptra(istr,:)
              END IF
!                              Extrapolate PSI-points at top edge
!
              IF (tile.ge.(ntilei(ng)*(ntilej(ng)-1))) THEN
                ptrx(:,jend+2)=2.0_dp*ptrx(:,jend+1)-ptrx(:,jend)
                ptry(:,jend+2)=2.0_dp*ptry(:,jend+1)-ptry(:,jend)
                ptrm(:,jend+2)=ptrm(:,jend+1)
                ptra(:,jend+2)=ptra(:,jend+1)
              END IF
!                             Extrapolate PSI-points at right edge
!
              IF (mod(tile+1,ntilei(ng)).eq.0) THEN
                ptrx(iend+2,:)=2.0_dp*ptrx(iend+1,:)-ptrx(iend,:)
                ptry(iend+2,:)=2.0_dp*ptry(iend+1,:)-ptry(iend,:)
                ptrm(iend+2,:)=ptrm(iend+1,:)
                ptra(iend+2,:)=ptra(iend+1,:)
              END IF
!                                                        U-points
            CASE (iupoint)
              DO j=jstrr,jendr
                DO i=istr,iendr
                  ptrx(i,j)=grid(ng)%lonu(i,j)
                  ptry(i,j)=grid(ng)%latu(i,j)
# ifdef MASKING
                  ptrm(i,j)=int(grid(ng)%umask(i,j))
# else
                  ptrm(i,j)=1
# endif
                  ptra(i,j)=grid(ng)%om_u(i,j)*grid(ng)%on_u(i,j)
                END DO
              END DO
!                             Extrapolate U-points at left edge
!
              IF (mod(tile,ntilei(ng)).eq.0) THEN
                ptrx(istr-1,:)=2.0_dp*ptrx(istr,:)-ptrx(istr+1,:)
                ptry(istr-1,:)=2.0_dp*ptry(istr,:)-ptry(istr+1,:)
                ptrm(istr-1,:)=ptrm(istr,:)
                ptra(istr-1,:)=ptra(istr,:)
              END IF
!                             Extrapolate U-points at right edge
!
              IF (mod(tile+1,ntilei(ng)).eq.0) THEN
                ptrx(iend+2,:)=2.0_dp*ptrx(iend+1,:)-ptrx(iend,:)
                ptry(iend+2,:)=2.0_dp*ptry(iend+1,:)-ptry(iend,:)
                ptrm(iend+2,:)=ptrm(iend+1,:)
                ptra(iend+2,:)=ptra(iend+1,:)
              END IF
!                                                        V-points
            CASE (ivpoint)
              DO j=jstr,jendr
                DO i=istrr,iendr
                  ptrx(i,j)=grid(ng)%lonv(i,j)
                  ptry(i,j)=grid(ng)%latv(i,j)
# ifdef MASKING
                  ptrm(i,j)=int(grid(ng)%vmask(i,j))
# else
                  ptrm(i,j)=1
# endif
                  ptra(i,j)=grid(ng)%om_v(i,j)*grid(ng)%on_v(i,j)
                END DO
              END DO
!                             Extrapolate V-points at bottom edge
!
              IF (tile.lt.ntilei(ng)) THEN
                ptrx(:,jstr-1)=2.0_dp*ptrx(:,jstr)-ptrx(:,jstr+1)
                ptry(:,jstr-1)=2.0_dp*ptry(:,jstr)-ptry(:,jstr+1)
                ptrm(:,jstr-1)=ptrm(:,jstr)
                ptra(:,jstr-1)=ptra(:,jstr)
              END IF
!                             Extrapolate V-points at top edge
!
              IF (tile.ge.(ntilei(ng)*(ntilej(ng)-1))) THEN
                ptrx(:,jend+2)=2.0_dp*ptrx(:,jend+1)-ptrx(:,jend)
                ptry(:,jend+2)=2.0_dp*ptry(:,jend+1)-ptry(:,jend)
                ptrm(:,jend+2)=ptrm(:,jend+1)
                ptra(:,jend+2)=ptra(:,jend+1)
              END IF
          END SELECT
!
!  Nullify pointers.
!
          IF ( associated(ptrx) ) nullify (ptrx)
          IF ( associated(ptry) ) nullify (ptry)
          IF ( associated(ptrm) ) nullify (ptrm)
          IF ( associated(ptra) ) nullify (ptra)
        END DO de_loop
!
!  Debugging: write out component grid in VTK format.
!
        IF (debuglevel.ge.4) THEN
          gtype=models(iroms)%mesh(ivar)%gtype
          CALL esmf_gridwritevtk (models(iroms)%grid(ng),               &
     &                            filename="roms_"//                    &
     &                                     trim(gridtype(gtype))//      &
     &                                     "_point",                    &
     &                            staggerloc=staggerloc,                &
     &                            rc=rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
        END IF
      END DO mesh_loop
!
!  Assign grid to gridded component.
!
      CALL esmf_gridcompset (model,                                     &
     &                       grid=models(iroms)%grid(ng),               &
     &                       rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '<== Exiting  ROMS_SetGridArrays',      &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      IF (debuglevel.gt.0) FLUSH (cplout)
!
  10  FORMAT (/,'ROMS Domain Decomposition:',/,25('='),/,               &
              /,2x,'ROMS_DistGrid - Grid = ',i2.2,',',3x,'Mesh = ',a,   &
     &        ',',3x,'Partition = ',i0,' x ',i0)
  20  FORMAT (18x,'node = ',i0,t32,'Istr = ',i0,t45,'Iend = ',i0,       &
     &                         t58,'Jstr = ',i0,t71,'Jend = ',i0)
!
      RETURN
      END SUBROUTINE roms_setgridarrays
!
      SUBROUTINE roms_setstates (ng, tile, model, rc)
!
!=======================================================================
!                                                                      !
!  Adds ROMS component export and import fields into its respective    !
!  state.                                                              !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(in)  :: ng, tile
      integer, intent(out) :: rc
!
      TYPE (esmf_gridcomp) :: model
!
!  Local variable declarations.
!
      integer :: id, ifld
      integer :: localde, localdecount, localpet
      integer :: exportcount, importcount
!
      real (dp), dimension(:,:), pointer :: ptr2d => null()
!
      character (len=10) :: attlist(1)
 
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", ROMS_SetStates"
!
      character (ESMF_MAXSTR), allocatable :: exportnamelist(:)
      character (ESMF_MAXSTR), allocatable :: importnamelist(:)
!
      TYPE (esmf_arrayspec)  :: arrayspec2d
      TYPE (esmf_field)      :: field, field_scalar
      TYPE (esmf_staggerloc) :: staggerloc
      TYPE (esmf_vm)         :: vm
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '==> Entering ROMS_SetStates',          &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  Query gridded component.
!-----------------------------------------------------------------------
!
!  Get import and export states.
!
      CALL esmf_gridcompget (model,                                     &
     &                       localpet=localpet,                         &
     &                       vm=vm,                                     &
     &                       rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Get number of local decomposition elements (DEs). Usually, a single
!  Decomposition Element (DE) is associated with each Persistent
!  Execution Thread (PETs). Thus, localDEcount=1.
!
      CALL esmf_gridget (models(iroms)%grid(ng),                        &
     &                   localdecount=localdecount,                     &
     &                   rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Set a 2D floating-point array descriptor.
!-----------------------------------------------------------------------
!
      CALL esmf_arrayspecset (arrayspec2d,                              &
     &                        typekind=esmf_typekind_r8,                &
     &                        rank=2,                                   &
     &                        rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Add export fields into export state.
!-----------------------------------------------------------------------
!
      exporting : IF (nexport(iroms).gt.0) THEN
!
!  Get number of fields to export.
!
        CALL esmf_stateget (models(iroms)%ExportState(ng),              &
     &                      itemcount=exportcount,                      &
     &                      rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
!
!  Get a list of export fields names.
!
        IF (.not.allocated(exportnamelist)) THEN
          allocate ( exportnamelist(exportcount) )
        END IF
        CALL esmf_stateget (models(iroms)%ExportState(ng),              &
     &                      itemnamelist=exportnamelist,                &
     &                      rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
!
!  Set export field(s).
!
        DO ifld=1,exportcount
          id=field_index(models(iroms)%ExportField,exportnamelist(ifld))
!
          IF (nuopc_isconnected(models(iroms)%ExportState(ng),          &
     &                          fieldname=trim(exportnamelist(ifld)),   &
     &                          rc=rc)) THEN
!
!  If cmeps scalar field, 'cpl_scalars', add it to Export State.
!
            IF (trim(exportnamelist(ifld)).eq.                          &
     &          trim(scalarfieldname)) THEN
!
!  Create scalar field.
!
              CALL createscalarfield(field,                             &
     &                               scalarfieldname,                   &
     &                               scalarfieldcount,                  &
     &                               rc)
              IF (esmf_logfounderror(rctocheck=rc,                      &
     &                               msg=esmf_logerr_passthru,          &
     &                               line=__line__,                     &
     &                               file=myfile)) THEN
                RETURN
              END IF
!
!  Set values and fill scalar field.
!
              CALL setscalarfieldvalues(field,                          &
     &                                  (/ lm(ng)+2, mm(ng)+2 /),       &
     &                                  (/ scalarfieldidxgridnx,        &
     &                                     scalarfieldidxgridny /),     &
     &                                  rc=rc)
              IF (esmf_logfounderror(rctocheck=rc,                      &
     &                               msg=esmf_logerr_passthru,          &
     &                               line=__line__,                     &
     &                               file=myfile)) THEN
                RETURN
              END IF
!
!  Otherwise, proccess regular ROMS export field(s).
!
            ELSE
!
!  Set staggering type.
!
              SELECT CASE (models(iroms)%ExportField(id)%gtype)
                CASE (icenter)                                ! RHO-points
                  staggerloc=esmf_staggerloc_center
                CASE (icorner)                                ! PSI-points
                  staggerloc=esmf_staggerloc_corner
                CASE (iupoint)                                ! U-points
                  staggerloc=esmf_staggerloc_edge1
                CASE (ivpoint)                                ! V-points
                  staggerloc=esmf_staggerloc_edge2
              END SELECT
!
!  Create 2D field from the Grid and arraySpec.
!
              field=esmf_fieldcreate(models(iroms)%grid(ng),            &
     &                               arrayspec2d,                       &
     &                               indexflag=esmf_index_global,       &
     &                               staggerloc=staggerloc,             &
     &                               name=trim(exportnamelist(ifld)),   &
     &                               rc=rc)
              IF (esmf_logfounderror(rctocheck=rc,                      &
     &                               msg=esmf_logerr_passthru,          &
     &                               line=__line__,                     &
     &                               file=myfile)) THEN
                RETURN
              END IF
!
!  Put data into state. Usually, the DO-loop is executed once since
!  localDEcount=1.
!
              DO localde=0,localdecount-1
!
!  Get pointer to DE-local memory allocation within field.
!
                CALL esmf_fieldget (field,                              &
     &                              localde=localde,                    &
     &                              farrayptr=ptr2d,                    &
     &                              rc=rc)
                IF (esmf_logfounderror(rctocheck=rc,                    &
     &                                 msg=esmf_logerr_passthru,        &
     &                                 line=__line__,                   &
     &                                 file=myfile)) THEN
                  RETURN
                END IF
!
!  Initialize pointer.
!
                ptr2d=missing_dp
!
!  Nullify pointer to make sure that it does not point on a random part
!  in the memory.
!
                IF ( associated(ptr2d) ) nullify (ptr2d)
              END DO
!
            END IF
!
!  Add field export state.
!
            CALL nuopc_realize (models(iroms)%ExportState(ng),          &
     &                          field=field,                            &
     &                          rc=rc)
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
!
!  Remove field from export state because it is not connected.
!
          ELSE
            IF (trim(exportnamelist(id)).ne.trim(scalarfieldname)) THEN
              IF (localpet.eq.0) THEN
                WRITE (cplout,10) trim(exportnamelist(ifld)),           &
     &                            'Export State: ',                     &
     &                            trim(coupled(iroms)%ExpLabel(ng))
              END IF
              CALL esmf_stateremove (models(iroms)%ExportState(ng),     &
     &                               (/ trim(exportnamelist(ifld)) /),  &
     &                               rc=rc)
              IF (esmf_logfounderror(rctocheck=rc,                      &
     &                               msg=esmf_logerr_passthru,          &
     &                               line=__line__,                     &
     &                               file=myfile)) THEN
                RETURN
              END IF
            END IF
          END IF
        END DO
!
!  Deallocate arrays.
!
        IF ( allocated(exportnamelist) ) deallocate (exportnamelist)
!
      END IF exporting
!
!-----------------------------------------------------------------------
!  Add import fields into import state.
!-----------------------------------------------------------------------
!
      importing : IF (nimport(iroms).gt.0) THEN
!
!  Get number of fields to import.
!
        CALL esmf_stateget (models(iroms)%ImportState(ng),              &
     &                      itemcount=importcount,                      &
     &                      rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
!
!  Get a list of import fields names.
!
        IF (.not.allocated(importnamelist)) THEN
          allocate (importnamelist(importcount))
        END IF
        CALL esmf_stateget (models(iroms)%ImportState(ng),              &
     &                      itemnamelist=importnamelist,                &
     &                      rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
!
!  Set import field(s).
!
        DO ifld=1,importcount
          id=field_index(models(iroms)%ImportField,importnamelist(ifld))
!
          IF (nuopc_isconnected(models(iroms)%ImportState(ng),          &
     &                          fieldname=trim(importnamelist(ifld)),   &
     &                          rc=rc)) THEN
!
!  Set staggering type.
!
            SELECT CASE (models(iroms)%ImportField(id)%gtype)
              CASE (icenter)                                ! RHO-points
                staggerloc=esmf_staggerloc_center
              CASE (icorner)                                ! PSI-points
                staggerloc=esmf_staggerloc_corner
              CASE (iupoint)                                ! U-points
                staggerloc=esmf_staggerloc_edge1
              CASE (ivpoint)                                ! V-points
                staggerloc=esmf_staggerloc_edge2
            END SELECT
!
!  Create 2D field from the Grid, arraySpec, total tile size.
!  The array indices are global following ROMS design.
!
            field=esmf_fieldcreate(models(iroms)%grid(ng),              &
     &                             arrayspec2d,                         &
     &                             indexflag=esmf_index_global,         &
     &                             staggerloc=staggerloc,               &
     &                             name=trim(importnamelist(ifld)),     &
     &                             rc=rc)
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
 
# ifdef TIME_INTERP_NOT
!
!  Create standard Attribute Package for each export field. Then, nest
!  custom Attribute Package around it.
!
            CALL esmf_attributeadd (field,                              &
     &                              convention='ESMF',                  &
     &                              purpose='General',                  &
     &                              rc=rc)
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
!
            attlist(1)='TimeInterp'
            CALL esmf_attributeadd (field,                              &
     &                              convention='CustomConvention',      &
     &                              purpose='General',                  &
!!   &                              purpose='Instance',                 &
     &                              attrlist=attlist,                   &
     &                              nestconvention='ESMF',              &
     &                              nestpurpose='General',              &
     &                              rc=rc)
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
# endif
!
!  Put data into state. Usually, the DO-loop is executed once since
!  localDEcount=1.
!
            DO localde=0,localdecount-1
!
!  Get pointer to DE-local memory allocation within field.
!
              CALL esmf_fieldget (field,                                &
     &                            localde=localde,                      &
     &                            farrayptr=ptr2d,                      &
     &                            rc=rc)
              IF (esmf_logfounderror(rctocheck=rc,                      &
     &                               msg=esmf_logerr_passthru,          &
     &                               line=__line__,                     &
     &                               file=myfile)) THEN
                RETURN
              END IF
!
!  Initialize pointer.
!
              ptr2d=missing_dp
!
!  Nullify pointer to make sure that it does not point on a random
!  part in the memory.
!
              IF (associated(ptr2d)) nullify (ptr2d)
            END DO
!
!  Add field import state.
!
            CALL nuopc_realize (models(iroms)%ImportState(ng),          &
     &                          field=field,                            &
     &                          rc=rc)
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
!
!  Remove field from import state because it is not connected.
!
          ELSE
            IF (localpet.eq.0) THEN
              WRITE (cplout,10) trim(importnamelist(ifld)),             &
     &                          'Import State: ',                       &
     &                          trim(coupled(iroms)%ImpLabel(ng))
            END IF
            CALL esmf_stateremove (models(iroms)%ImportState(ng),       &
     &                             (/ trim(importnamelist(ifld)) /),    &
     &                             rc=rc)
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
          END IF
        END DO
!
!  Deallocate arrays.
!
        IF (allocated(importnamelist)) deallocate (importnamelist)
!
      END IF importing
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '<== Exiting  ROMS_SetStates',          &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
!
 10   FORMAT (1x,'ROMS_SetStates - Removing field ''',a,''' from ',a,   &
     &        '''',a,'''',/,18x,'because it is not connected.')
!
      RETURN
      END SUBROUTINE roms_setstates
!
      SUBROUTINE roms_modeladvance (model, rc)
!
!=======================================================================
!                                                                      !
!  Advance ROMS component for a coupling interval (seconds) using      !
!  "ROMS_run". It also calls "ROMS_Import" and "ROMS_Export" to        !
!  import and export coupling fields, respectively.                    !
!                                                                      !
!  During configuration, the driver clock was decreased by a single    !
!  coupling interval (TimeStep) to allow the proper initialization     !
!  of the import and export fields pointers.  ROMS is not advanced     !
!  on the first call to this routine, so the time stepping is over     !
!  the specified application start and ending dates.                   !
!                                                                      !
# if defined TIME_INTERP
!  On the first pass, it imports the LOWER time snapshot fields,       !
!  but cannot time-step ROMS until the next call after importing       !
!  the UPPER snapshot.  Therefore, it starts time-stepping when        !
!  both LOWER and UPPER time snapshot fields are exchanged so that     !
!  ROMS can perform time interpolation.                                !
# else
!  ROMS is actually advanced on the second call to this routine.       !
# endif
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(out) :: rc
!
      TYPE (esmf_gridcomp) :: model
!
!  Local variable declarations.
!
      logical :: ladvance
      integer :: is, ng
      integer :: mytask, petcount, localpet, phase
!
      real (dp) :: couplinginterval, runinterval
      real (dp) :: tcurrentinseconds, tstopinseconds
!
      character (len=22) :: cinterval
      character (len=22) :: currtimestring, stoptimestring
 
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", ROMS_SetModelAdvance"
!
      TYPE (esmf_clock)        :: clock
      TYPE (esmf_state)        :: exportstate, importstate
      TYPE (esmf_time)         :: referencetime
      TYPE (esmf_time)         :: currenttime, stoptime
      TYPE (esmf_timeinterval) :: timestep
      TYPE (esmf_vm)           :: vm
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '==> Entering ROMS_ModelAdvance',       &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  Get information about the gridded component.
!-----------------------------------------------------------------------
!
!  Inquire about ROMS component.
!
      CALL esmf_gridcompget (model,                                     &
     &                       importstate=importstate,                   &
     &                       exportstate=exportstate,                   &
     &                       clock=clock,                               &
     &                       localpet=localpet,                         &
     &                       petcount=petcount,                         &
     &                       currentphase=phase,                        &
     &                       vm=vm,                                     &
     &                       rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Get time step interval, stopping time, reference time, and current
!  time.
!
      CALL esmf_clockget (clock,                                        &
     &                    timestep=timestep,                            &
     &                    stoptime=stoptime,                            &
     &                    reftime=referencetime,                        &
     &                    currtime=clockinfo(iroms)%CurrentTime,        &
     &                    rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Current ROMS time (seconds).
!
      CALL esmf_timeget (clockinfo(iroms)%CurrentTime,                  &
     &                   s_r8=tcurrentinseconds,                        &
     &                   timestringisofrac=currtimestring,              &
     &                   rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
      is=index(currtimestring, 'T')                 ! remove 'T' in
      IF (is.gt.0) currtimestring(is:is)=' '        ! ISO 8601 format
!
!  ROMS stop time (seconds) for this coupling window.
!
      CALL esmf_timeget (clockinfo(iroms)%CurrentTime+timestep,         &
     &                   s_r8=tstopinseconds,                           &
     &                   timestringisofrac=stoptimestring,              &
     &                   rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
      is=index(stoptimestring, 'T')                 ! remove 'T' in
      IF (is.gt.0) stoptimestring(is:is)=' '        ! ISO 8601 form
!
!  Get coupling time interval (seconds, double precision).
!
      CALL esmf_timeintervalget (timestep,                              &
     &                           s_r8=couplinginterval,                 &
     &                           rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Set ROMS running interval (seconds) for the current coupling window.
!
      runinterval=couplinginterval
!
!  Set local model advance time stepping switch.
!
      ladvance=.true.
# ifdef TIME_INTERP
      IF ((models(iroms)%ImportCalls.eq.0).and.                         &
     &    (nimport(iroms).gt.0)) THEN
        ladvance=.false.
      END IF
# else
#  ifdef REGRESS_STARTCLOCK
      IF (tcurrentinseconds.eq.clockinfo(idriver)%Time_Start) THEN
        ladvance=.false.
      END IF
#  endif
# endif
!
!-----------------------------------------------------------------------
!  Report time information strings (YYYY-MM-DD hh:mm:ss).
!-----------------------------------------------------------------------
!
      IF (localpet.eq.0) THEN
        WRITE (cinterval,'(f15.2)') couplinginterval
        WRITE (cplout,10) trim(currtimestring), trim(stoptimestring),   &
     &                    trim(adjustl(cinterval)), ladvance
      END IF
!
!-----------------------------------------------------------------------
!  Get import fields from other ESM components.
!-----------------------------------------------------------------------
!
      IF (nimport(iroms).gt.0) THEN
        DO ng=1,models(iroms)%Ngrids
          IF (any(coupled(iroms)%LinkedGrid(ng,:))) THEN
            CALL roms_import (ng, model, rc)
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
          END IF
       END DO
     END IF
!
!-----------------------------------------------------------------------
!  Run ROMS component. Notice that ROMS component is advanced when
!  ng=1.  In nested application, ROMS kernel (main2d or main3d) will
!  advance all the nested grid in their logical order.  In nesting,
!  the execution order of the grids is critical since nesting is
!  two-way by default.
!-----------------------------------------------------------------------
!
      IF (ladvance) THEN
        IF (esm_track) THEN
          WRITE (trac,'(a,a,i0)') '==> Entering ROMS_Run',              &
     &                            ', PET', petrank
          FLUSH (trac)
        END IF
        CALL roms_run (runinterval)
        IF (esm_track) THEN
          WRITE (trac,'(a,a,i0)') '==> Exiting  ROMS_Run',              &
     &                            ', PET', petrank
          FLUSH (trac)
        END IF
      END IF
!
      IF (exit_flag.ne.noerror) then
        IF (localpet.eq.0) then
          WRITE (cplout,'(a,i1)') 'ROMS component exit with flag = ',   &
     &                            exit_flag
        END IF
        CALL roms_finalize
        CALL esmf_finalize (endflag=esmf_end_abort)
      END IF
!
!-----------------------------------------------------------------------
!  Put export fields.
!-----------------------------------------------------------------------
!
      IF (nexport(iroms).gt.0) THEN
        DO ng=1,models(iroms)%Ngrids
          IF (any(coupled(iroms)%LinkedGrid(ng,:))) THEN
            CALL roms_export (ng, model, rc)
            IF (esmf_logfounderror(rctocheck=rc,                        &
     &                             msg=esmf_logerr_passthru,            &
     &                             line=__line__,                       &
     &                             file=myfile)) THEN
              RETURN
            END IF
          END IF
        END DO
      END IF
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '<== Exiting  ROMS_ModelAdvance',       &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
!
  10  FORMAT (3x,'ModelAdvance - ESMF, Running ROMS:',t42,a,            &
     &        ' => ',a,', [',a,' s], Advance: ',l1)
!
      RETURN
      END SUBROUTINE roms_modeladvance
!
      SUBROUTINE roms_setfinalize (model,                               &
     &                             ImportState, ExportState,            &
     &                             clock, rc)
!
!=======================================================================
!                                                                      !
!  Finalize ROMS component execution. It calls ROMS_finalize.          !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(out) :: rc
!
      TYPE (esmf_clock)    :: clock
      TYPE (esmf_gridcomp) :: model
      TYPE (esmf_state)    :: exportstate
      TYPE (esmf_state)    :: importstate
!
!  Local variable declarations.
!
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", ROMS_SetFinalize"
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '==> Entering ROMS_SetFinalize',        &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  If ng=1, finalize ROMS component. In nesting applications this step
!  needs to be done only once.
!-----------------------------------------------------------------------
!
      CALL roms_finalize
      FLUSH (cplout)                      ! flush coupling output buffer
      CLOSE (cplout)                      ! close coupling log file
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '<== Exiting  ROMS_SetFinalize',        &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
!
      RETURN
      END SUBROUTINE roms_setfinalize
!
      SUBROUTINE roms_import (ng, model, rc)
!
!=======================================================================
!                                                                      !
!  Imports fields into ROMS array structures. The fields aew loaded    !
!  into the snapshot storage arrays to allow time interpolation in     !
!  ROMS kernel.                                                        !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(in)  :: ng
      integer, intent(out) :: rc
!
      TYPE (esmf_gridcomp) :: model
!
!  Local variable declarations.
!
      logical :: loadit, ispresent
      logical :: got_stress(2), got_wind(2)
# if defined WIND_MINUS_CURRENT && !defined BULK_FLUXES
      logical :: got_rhoair, got_wstar, got_wind_sbl(2)
# endif
!
      integer :: istr,  iend,  jstr,  jend
      integer :: istrr, iendr, jstrr, jendr
      integer :: lbi, ubi, lbj, ubj
      integer :: importcount, tindex
      integer :: localde, localdecount, localpet, tile
      integer :: year, month, day, hour, minutes, seconds, sn, sd
      integer :: gtype, id, ifield, ifld, i, is, j
!
# ifdef TIME_INTERP
      integer, save :: record = 0
!
# endif
      real (dp), parameter :: eps = 1.0e-10_dp
!
      real (dp) :: timeindays, time_current, tmin, tmax, tstr, tend
# ifdef TIME_INTERP
      real (dp) :: mytimeindays
# endif
      real (dp) :: fseconds, romsclocktime
      real (dp) :: mytintrp(2), myvtime(2)
 
      real (dp) :: myfmax(2), myfmin(2), fmin(2), fmax(2), fval
      real (dp) :: add_offset, romsscale, scale, cff1, cff2, cff3
      real (dp) :: freshwaterscale, stressscale, tracerfluxscale
# if defined WIND_MINUS_CURRENT && !defined BULK_FLUXES
      real (dp) :: urel, vrel, wmag, wrel
# endif
      real (dp) :: attvalues(14)
!
      real (dp), pointer :: ptr2d(:,:) => null()
!
# if defined WIND_MINUS_CURRENT && !defined BULK_FLUXES
      real (dp), allocatable  :: rhoair(:,:),  wstar(:,:)
      real (dp), allocatable  :: uwrk(:,:),    vwrk(:,:)
      real (dp), allocatable  :: xwind(:,:),   ywind(:,:)
# endif
      real (dp), allocatable  :: ustress(:,:), vstress(:,:)
      real (dp), allocatable  :: uwind(:,:),   vwind(:,:)
!
      character (len=22)      :: mydate(2)
# ifdef TIME_INTERP
      character (len=22)      :: mydatestring(1,1,1)
# endif
      character (len=22)      :: time_currentstring
      character (len=40)      :: attname
 
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", ROMS_Import"
 
      character (ESMF_MAXSTR) :: cname, ofile
      character (ESMF_MAXSTR), allocatable :: importnamelist(:)
!
      TYPE (esmf_attpack) :: attpack
      TYPE (esmf_clock)   :: clock
      TYPE (esmf_field)   :: field
      TYPE (esmf_time)    :: currenttime
      TYPE (esmf_vm)      :: vm
 
# ifdef TIME_INTERP
!
      sourcefile=myfile
# endif
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '==> Entering ROMS_Import',             &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  Get information about the gridded component.
!-----------------------------------------------------------------------
!
      CALL esmf_gridcompget (model,                                     &
     &                       clock=clock,                               &
     &                       localpet=localpet,                         &
     &                       vm=vm,                                     &
     &                       name=cname,                                &
     &                       rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Get number of local decomposition elements (DEs). Usually, a single
!  DE is associated with each Persistent Execution Thread (PETs). Thus,
!  localDEcount=1.
!
      CALL esmf_gridget (models(iroms)%grid(ng),                        &
     &                   localdecount=localdecount,                     &
     &                   rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Set size of imported tiled-arrays.
!
      tile=localpet
!
      lbi=bounds(ng)%LBi(tile)        ! lower bound I-direction
      ubi=bounds(ng)%UBi(tile)        ! upper bound I-direction
      lbj=bounds(ng)%LBj(tile)        ! lower bound J-direction
      ubj=bounds(ng)%UBj(tile)        ! upper bound J-direction
!
      istrr=bounds(ng)%IstrR(tile)    ! Full range I-starting (RHO)
      iendr=bounds(ng)%IendR(tile)    ! Full range I-ending   (RHO)
      jstrr=bounds(ng)%JstrR(tile)    ! Full range J-starting (RHO)
      jendr=bounds(ng)%JendR(tile)    ! Full range J-ending   (RHO)
!
      istr=bounds(ng)%Istr(tile)      ! Full range I-starting (PSI, U)
      iend=bounds(ng)%Iend(tile)      ! Full range I-ending   (PSI)
      jstr=bounds(ng)%Jstr(tile)      ! Full range J-starting (PSI, V)
      jend=bounds(ng)%Jend(tile)      ! Full range J-ending   (PSI)
!
!-----------------------------------------------------------------------
!  Get current time.
!-----------------------------------------------------------------------
!
      CALL esmf_clockget (clock,                                        &
     &                    currtime=currenttime,                         &
     &                    rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      CALL esmf_timeget (currenttime,                                   &
     &                   yy=year,                                       &
     &                   mm=month,                                      &
     &                   dd=day,                                        &
     &                   h =hour,                                       &
     &                   m =minutes,                                    &
     &                   s =seconds,                                    &
     &                   sn=sn,                                         &
     &                   sd=sd,                                         &
     &                   rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      CALL esmf_timeget (currenttime,                                   &
     &                   s_r8=time_current,                             &
     &                   timestring=time_currentstring,                 &
     &                   rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
      timeindays=time_current/86400.0_dp
      is=index(time_currentstring, 'T')              ! remove 'T' in
      IF (is.gt.0) time_currentstring(is:is)=' '     ! ISO 8601 format
!
!-----------------------------------------------------------------------
!  Convert CurrentTime into ROMS clock ellapsed time since
!  initialization in seconds from reference time.
!  (The routine "ROMS_clock" is located in ROMS/Utility/dateclock.F)
!-----------------------------------------------------------------------
!
      fseconds=real(seconds,dp)+real(sn,dp)/real(sd,dp)
      CALL roms_clock (year, month, day, hour, minutes, fseconds,       &
     &                 romsclocktime)
!
!-----------------------------------------------------------------------
!  Get list of import fields.
!-----------------------------------------------------------------------
!
      CALL esmf_stateget (models(iroms)%ImportState(ng),                &
     &                    itemcount=importcount,                        &
     &                    rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      IF (.not.allocated(importnamelist)) THEN
        allocate ( importnamelist(importcount) )
      END IF
      CALL esmf_stateget (models(iroms)%ImportState(ng),                &
     &                    itemnamelist=importnamelist,                  &
     &                    rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
 
# ifdef TIME_INTERP
!
!-----------------------------------------------------------------------
!  Advance unlimited dimension counter.
!-----------------------------------------------------------------------
!
      IF (petlayoutoption.eq.'CONCURRENT') THEN
        record=record+1
      END IF
# endif
!
!-----------------------------------------------------------------------
!  Get import fields.
!-----------------------------------------------------------------------
!
!  Set switches to rotate wind stress and wind component for curvilinear
!  ROMS grid applications.
!
      got_stress(1:2)=.false.
      got_wind(1:2)=.false.
# if defined WIND_MINUS_CURRENT && !defined BULK_FLUXES
      got_rhoair=.false.
      got_wstar=.false.
      got_wind_sbl(1:2)=.false.
# endif
!
!  Loop over all import fields to process.
!
      fld_loop : DO ifld=1,importcount
        id=field_index(models(iroms)%ImportField, importnamelist(ifld))
!
!  Get field from import state.
!
        CALL esmf_stateget (models(iroms)%ImportState(ng),              &
     &                      trim(importnamelist(ifld)),                 &
     &                      field,                                      &
     &                      rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
 
# ifdef TIME_INTERP
!
!  If cuncurrent coupling and importing time snapshots, update values
!  in the MODELS(Iroms)%ImportField structure by reading import field
!  interpolation attributes from source NetCDF file. It is very tricky
!  to perform inter VM communications. It is easier to read them from
!  a NetCDF file.  ROMS needs these attributes to perform the time
!  interpolation between snapshots in its kernel.
!  (HGA: need to figure out how to do inter VM communications)
!
        IF (petlayoutoption.eq.'CONCURRENT') THEN
          CALL netcdf_get_ivar (ng, inlm, attfilename, 'Tindex',        &
     &                          models(iroms)%ImportField(id)%Tindex,   &
     &                          start=(/iroms,id,record/),              &
     &                          total=(/1,1,1/))
          IF (founderror(exit_flag, noerror, __line__,                  &
     &                   myfile)) THEN
            rc=esmf_rc_file_read
            RETURN
          END IF
!
          is=models(iroms)%ImportField(id)%Tindex
          CALL netcdf_get_svar (ng, inlm, attfilename, 'Date',          &
     &                          mydatestring,                           &
     &                          start=(/1,iroms,id,record/),            &
     &                          total=(/22,1,1,1/))
          IF (founderror(exit_flag, noerror, __line__,                  &
     &                   myfile)) THEN
            rc=esmf_rc_file_read
            RETURN
          END IF
          models(iroms)%ImportField(id)%DateString(is)=                 &
     &                                               mydatestring(1,1,1)
!
          CALL netcdf_get_time (ng, inlm, attfilename, 'Tcurrent',      &
     &                          rclock%DateNumber, mytimeindays,        &
     &                          start=(/iroms,id,record/),              &
     &                          total=(/1,1,1/))
          IF (founderror(exit_flag, noerror, __line__,                  &
     &                   myfile)) THEN
            rc=esmf_rc_file_read
            RETURN
          END IF
!
          CALL netcdf_get_time (ng, inlm, attfilename, 'Tstr',          &
     &                          rclock%DateNumber,                      &
     &                          models(iroms)%ImportField(id)%Tstr,     &
     &                          start=(/iroms,id,record/),              &
     &                          total=(/1,1,1/))
          IF (founderror(exit_flag, noerror, __line__,                  &
     &                   myfile)) THEN
            rc=esmf_rc_file_read
            RETURN
          END IF
!
          CALL netcdf_get_time (ng, inlm, attfilename, 'Tend',          &
     &                          rclock%DateNumber,                      &
     &                          models(iroms)%ImportField(id)%Tend,     &
     &                          start=(/iroms,id,record/),              &
     &                          total=(/1,1,1/))
          IF (founderror(exit_flag, noerror, __line__,                  &
     &                   myfile)) THEN
            rc=esmf_rc_file_read
            RETURN
          END IF
!
          CALL netcdf_get_time (ng, inlm, attfilename, 'Tintrp',        &
     &                          rclock%DateNumber,                      &
     &                        models(iroms)%ImportField(id)%Tintrp(is), &
     &                          start=(/iroms,id,record/),              &
     &                          total=(/1,1,1/))
          IF (founderror(exit_flag, noerror, __line__,                  &
     &                   myfile)) THEN
            rc=esmf_rc_file_read
            RETURN
          END IF
!
          CALL netcdf_get_time (ng, inlm, attfilename, 'Vtime',         &
     &                          rclock%DateNumber,                      &
     &                        models(iroms)%ImportField(id)%Vtime(is),  &
     &                          start=(/iroms,id,record/),              &
     &                          total=(/1,1,1/))
          IF (founderror(exit_flag, noerror, __line__,                  &
     &                   myfile)) THEN
            rc=esmf_rc_file_read
            RETURN
          END IF
          CALL netcdf_get_time (ng, inlm, attfilename, 'Tmin',          &
     &                          rclock%DateNumber,                      &
     &                          models(iroms)%ImportField(id)%Tmin,     &
     &                          start=(/iroms,id,record/),              &
     &                          total=(/1,1,1/))
          IF (founderror(exit_flag, noerror, __line__,                  &
     &                   myfile)) THEN
            rc=esmf_rc_file_read
            RETURN
          END IF
!
          CALL netcdf_get_time (ng, inlm, attfilename, 'Tmax',          &
     &                          rclock%DateNumber,                      &
     &                          models(iroms)%ImportField(id)%Tmax,     &
     &                          start=(/iroms,id,record/),              &
     &                          total=(/1,1,1/))
          IF (founderror(exit_flag, noerror, __line__,                  &
     &                   myfile)) THEN
            rc=esmf_rc_file_read
            RETURN
          END IF
        END IF
# endif
!
!  Get field pointer.  Usually, the DO-loop is executed once since
!  localDEcount=1.
!
        de_loop : DO localde=0,localdecount-1
          CALL esmf_fieldget (field,                                    &
     &                        localde=localde,                          &
     &                        farrayptr=ptr2d,                          &
     &                        rc=rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
 
# ifdef TIME_INTERP_NOT_WORKING
!
!  Retrieve custom Attribute Package.
!
          CALL esmf_attributegetattpack (field,                         &
     &                                   'CustomConvention',            &
     &                                   'General',                     &
!!   &                                   'Instance',                    &
     &                                   attpack=attpack,               &
     &                                   ispresent=ispresent,           &
     &                                   rc=rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
!
!  Get field custom attribute for field for time interpolation.
!
          CALL esmf_attributeget (field,                                &
     &                            name='TimeInterp',                    &
     &                            valuelist=attvalues,                  &
     &                            attpack=attpack,                      &
     &                            ispresent=ispresent,                  &
     &                            rc=rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
# endif
!
!  Load import data into ROMS component variable.
# ifdef TIME_INTERP
!  If time interpolating in ROMS kernel, loaded import data into
!  snapshot storage arrays so time interpolating is carry out.
!  It is a generic strategy for the case that coupling interval
!  is greater than ROMS time-step size. Usually, time persisting
!  of coupling data may alter ocean solution. For example, it may
!  affect the ocean circulation/energetics if atmospheric forcing
!  is persisted during infrequent coupling (like every 3, 6, or
!  24 hours and so on).
# endif
!
          loadit=.true.
          scale      =models(iroms)%ImportField(id)%scale_factor
          add_offset =models(iroms)%ImportField(id)%add_offset
          tindex     =models(iroms)%ImportField(id)%Tindex
# ifdef TIME_INTERP
          tmin       =models(iroms)%ImportField(id)%Tmin
          tmax       =models(iroms)%ImportField(id)%Tmax
          tstr       =models(iroms)%ImportField(id)%Tstr
          tend       =models(iroms)%ImportField(id)%Tend
          mytintrp(1)=models(iroms)%ImportField(id)%Tintrp(1)
          mytintrp(2)=models(iroms)%ImportField(id)%Tintrp(2)
          myvtime(1) =models(iroms)%ImportField(id)%Vtime(1)
          myvtime(2) =models(iroms)%ImportField(id)%Vtime(2)
          mydate(1)  =models(iroms)%ImportField(id)%DateString(1)
          mydate(2)  =models(iroms)%ImportField(id)%DateString(2)
# endif
!
!  Set ROMS momentum fluxes and tracer flux scales to kinematic values.
!  Recall, that all the fluxes are kinematic.
!
          freshwaterscale=1.0_dp/rho0           ! Kg m-2 s-1 to m/s
          stressscale=1.0_dp/rho0               ! Pa=N m-2 to m2/s2
          tracerfluxscale=1.0_dp/(rho0*cp)      ! Watts m-2 to C m/s
!
          fval=ptr2d(istrr,jstrr)
          myfmin(1)= missing_dp
          myfmax(1)=-missing_dp
          myfmin(2)= missing_dp
          myfmax(2)=-missing_dp
!
          SELECT CASE (trim(adjustl(importnamelist(ifld))))
 
# if defined BULK_FLUXES || defined ECOSIM || defined ATM_PRESS
!
!  Surface air pressure or mean sea level pressure (mb).
!
            CASE ('psfc', 'Pair', 'Pmsl')
              romsscale=scale
              ifield=idpair
              gtype=r2dvar
              tindex=3-iinfo(8,ifield,ng)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),ptr2d(i,j))
                  myfmax(1)=max(myfmax(1),ptr2d(i,j))
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
#  ifdef TIME_INTERP
                  forces(ng)%PairG(i,j,tindex)=fval
#  else
                  forces(ng)%Pair(i,j)=fval
#  endif
                END DO
              END DO
#  ifndef TIME_INTERP
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    forces(ng)%Pair)
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              forces(ng)%Pair)
              END IF
#  endif
# endif
# if defined BULK_FLUXES || defined ECOSIM        || \
    (defined shortwave   && defined ana_srflux    && defined albedo)
!
!  Surface air temperature (Celsius).
!
            CASE ('tsfc', 'Tair')
              romsscale=scale
              ifield=idtair
              gtype=r2dvar
              tindex=3-iinfo(8,ifield,ng)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),ptr2d(i,j))
                  myfmax(1)=max(myfmax(1),ptr2d(i,j))
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
#  ifdef TIME_INTERP
                  forces(ng)%TairG(i,j,tindex)=fval
#  else
                  forces(ng)%Tair(i,j)=fval
#  endif
                END DO
              END DO
#  ifndef TIME_INTERP
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    forces(ng)%Tair)
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              forces(ng)%Tair)
              END IF
#  endif
# endif
# if defined BULK_FLUXES || defined ECOSIM
!
!  Surface air relative humidity (percentage). Notice that as the
!  specific humidity, it is loaded to FORCES(ng)%Hair and "bulk_flux.F"
!  will compute the specific humidity (kg/kg).
!
            CASE ('Qair')
              romsscale=scale
              ifield=idqair
              gtype=r2dvar
              tindex=3-iinfo(8,ifield,ng)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),ptr2d(i,j))
                  myfmax(1)=max(myfmax(1),ptr2d(i,j))
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
#  ifdef TIME_INTERP
                  forces(ng)%HairG(i,j,tindex)=fval
#  else
                  forces(ng)%Hair(i,j)=fval
#  endif
                END DO
              END DO
#  ifndef TIME_INTERP
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    forces(ng)%Hair)
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              forces(ng)%Hair)
              END IF
#  endif
# endif
# if defined BULK_FLUXES
!
!  Surface air specific humidity (kg kg-1).
!
            CASE ('Hair', 'qsfc')
              romsscale=scale
              ifield=idqair
              gtype=r2dvar
              tindex=3-iinfo(8,ifield,ng)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),ptr2d(i,j))
                  myfmax(1)=max(myfmax(1),ptr2d(i,j))
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
#  ifdef TIME_INTERP
                  forces(ng)%HairG(i,j,tindex)=fval
#  else
                  forces(ng)%Hair(i,j)=fval
#  endif
                END DO
              END DO
#  ifndef TIME_INTERP
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    forces(ng)%Hair)
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              forces(ng)%Hair)
              END IF
#  endif
# endif
# if defined BULK_FLUXES
!
!  Surface net longwave radiation (Celcius m s-1).
!
            CASE ('lwrd', 'LWrad')
              romsscale=tracerfluxscale
              ifield=idlrad
              gtype=r2dvar
              tindex=3-iinfo(8,ifield,ng)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),fval)
                  myfmax(1)=max(myfmax(1),fval)
                  fval=fval*romsscale
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
#  ifdef TIME_INTERP
                  forces(ng)%lrflxG(i,j,tindex)=fval
#  else
                  forces(ng)%lrflx(i,j)=fval
#  endif
                END DO
              END DO
#  ifndef TIME_INTERP
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    forces(ng)%lrflx)
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              forces(ng)%lrflx)
              END IF
#  endif
# endif
# if defined BULK_FLUXES && defined LONGWAVE_OUT
!
!  Surface downward longwave radiation (Celcius m s-1).  ROMS will
!  substract the outgoing IR from model sea surface temperature.
!
            CASE ('dlwr', 'dLWrad', 'lwrad_down')
              romsscale=tracerfluxscale
              ifield=idldwn
              gtype=r2dvar
              tindex=3-iinfo(8,ifield,ng)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),fval)
                  myfmax(1)=max(myfmax(1),fval)
                  fval=fval*romsscale
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
#  ifdef TIME_INTERP
                  forces(ng)%lrflxG(i,j,tindex)=fval
#  else
                  forces(ng)%lrflx(i,j)=fval
#  endif
                END DO
              END DO
#  ifndef TIME_INTERP
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    forces(ng)%lrflx)
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              forces(ng)%lrflx)
              END IF
#  endif
# endif
# if defined BULK_FLUXES
!
!  Rain fall rate (kg m-2 s-1).
!
            CASE ('prec', 'rain')
              romsscale=scale
              ifield=idrain
              gtype=r2dvar
              tindex=3-iinfo(8,ifield,ng)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),ptr2d(i,j))
                  myfmax(1)=max(myfmax(1),ptr2d(i,j))
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
#  ifdef TIME_INTERP
                  forces(ng)%rainG(i,j,tindex)=fval
#  else
                  forces(ng)%rain(i,j)=fval
#  endif
                END DO
              END DO
#  ifndef TIME_INTERP
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    forces(ng)%rain)
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              forces(ng)%rain)
              END IF
#  endif
# endif
# if defined BULK_FLUXES || defined ECOSIM
!
!  Surface eastward wind component (m s-1). Imported wind component
!  is at RHO-points.
!
            CASE ('wndu', 'Uwind')
              IF (.not.allocated(uwind)) THEN
                allocate ( uwind(lbi:ubi,lbj:ubj) )
                uwind=missing_dp
              END IF
              got_wind(1)=.true.
              romsscale=scale
              ifield=iduair
              gtype=r2dvar
              tindex=3-iinfo(8,ifield,ng)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),ptr2d(i,j))
                  myfmax(1)=max(myfmax(1),ptr2d(i,j))
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
#  ifdef TIME_INTERP
                  forces(ng)%UwindG(i,j,tindex)=fval
#  else
                  uwind(i,j)=fval
#  endif
                END DO
              END DO
#  ifndef TIME_INTERP
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    uwind)
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              uwind)
              END IF
#  endif
# endif
# if defined BULK_FLUXES || defined ECOSIM
!
!  Surface northward wind component (m s-1). Imported wind component
!  is at RHO-points.
!
            CASE ('wndv', 'Vwind')
              IF (.not.allocated(vwind)) THEN
                allocate ( vwind(lbi:ubi,lbj:ubj) )
                vwind=missing_dp
              END IF
              got_wind(2)=.true.
              romsscale=scale
              ifield=idvair
              gtype=r2dvar
              tindex=3-iinfo(8,ifield,ng)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),ptr2d(i,j))
                  myfmax(1)=max(myfmax(1),ptr2d(i,j))
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
#  ifdef TIME_INTERP
                  forces(ng)%VwindG(i,j,tindex)=fval
#  else
                  vwind(i,j)=fval
#  endif
                END DO
              END DO
#  ifndef TIME_INTERP
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    vwind)
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              vwind)
              END IF
#  endif
# endif
# if defined SHORTWAVE
!
!  Surface solar shortwave radiation (Celsius m s-1).
!
            CASE ('swrd', 'swrad', 'SWrad', 'SWrad_daily')
              romsscale=tracerfluxscale
              ifield=idsrad
              gtype=r2dvar
              tindex=3-iinfo(8,ifield,ng)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),fval)
                  myfmax(1)=max(myfmax(1),fval)
                  fval=fval*romsscale
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
#  ifdef TIME_INTERP
                  forces(ng)%srflxG(i,j,tindex)=fval
#  else
                  forces(ng)%srflx(i,j)=fval
#  endif
                END DO
              END DO
#  ifndef TIME_INTERP
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    forces(ng)%srflx)
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              forces(ng)%srflx)
              END IF
#  endif
# endif
# if !defined BULK_FLUXES
!
!  Net longwave radiation flux(W m-2). Used for debugging and plotting
!  purposes to check the fluxes used for the computation of the surface
!  net heat flux in NUOPC cap file "esmf_atm.F".
!
            CASE ('lwr', 'LWrad')
              romsscale=tracerfluxscale
              ifield=idlrad
              gtype=r2dvar
              tindex=3-iinfo(8,ifield,ng)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),fval)
                  myfmax(1)=max(myfmax(1),fval)
                  fval=fval*romsscale
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
                  forces(ng)%lrflx(i,j)=fval
                END DO
              END DO
!
!  Surface downward longwave radiation flux(W m-2). Used for debugging
!  and plotting purposes to check the fluxes used for the computation
!  of the surface net heat flux in NUOPC cap file "esmf_atm.F".
!
            CASE ('dlwr', 'dLWrad', 'lwrad_down')
              romsscale=tracerfluxscale
              ifield=idldwn
              gtype=r2dvar
              tindex=3-iinfo(8,ifield,ng)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),fval)
                  myfmax(1)=max(myfmax(1),fval)
                  fval=fval*romsscale
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
                  forces(ng)%lrflx(i,j)=fval
                END DO
              END DO
!
!  Surface latent heat flux (W m-2). Used for plotting and debugging
!  purposes (DebugLevel=3) to check the components of the net surface
!  net heat flux computation.
!
            CASE ('latent', 'LHfx')
              romsscale=tracerfluxscale
              gtype=r2dvar
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),fval)
                  myfmax(1)=max(myfmax(1),fval)
                  fval=fval*romsscale
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
                  forces(ng)%lhflx(i,j)=fval
                END DO
              END DO
!
!  Surface sensible heat flux (W m-2). Used for plotting and debugging
!  purposes (DebugLevel=3) to check the components of the net surface
!  net heat flux computation.
!
            CASE ('sensible', 'SHfx')
              romsscale=tracerfluxscale
              gtype=r2dvar
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),fval)
                  myfmax(1)=max(myfmax(1),fval)
                  fval=fval*romsscale
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
                  forces(ng)%shflx(i,j)=fval
                END DO
              END DO
!
!  Surface net heat flux (Celsius m s-1).
!
            CASE ('nflx', 'shflux')
              romsscale=tracerfluxscale
              ifield=idtsur(itemp)
              gtype=r2dvar
              tindex=3-iinfo(8,ifield,ng)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),fval)
                  myfmax(1)=max(myfmax(1),fval)
                  fval=fval*romsscale
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
#  ifdef TIME_INTERP
                  forces(ng)%stfluxG(i,j,tindex,itemp)=fval
#  else
                  forces(ng)%stflux(i,j,itemp)=fval
#  endif
                END DO
              END DO
#  ifndef TIME_INTERP
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    forces(ng)%stflux(:,:,itemp))
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              forces(ng)%stflux(:,:,itemp))
              END IF
#  endif
# endif
# if !defined BULK_FLUXES && defined SALINITY
!
!  Surface net freshwater flux: E-P (m s-1).
!
            CASE ('sflx', 'swflux')
              romsscale=freshwaterscale
              ifield=idtsur(isalt)
              gtype=r2dvar
              tindex=3-iinfo(8,ifield,ng)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),fval)
                  myfmax(1)=max(myfmax(1),fval)
                  fval=fval*romsscale
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
#  ifdef TIME_INTERP
                  forces(ng)%stfluxG(i,j,tindex,isalt)=fval
#  else
                  forces(ng)%stflux(i,j,isalt)=fval
#  endif
                END DO
              END DO
#  ifndef TIME_INTERP
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    forces(ng)%stflux(:,:,isalt))
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              forces(ng)%stflux(:,:,isalt))
              END IF
#  endif
# endif
# if !defined BULK_FLUXES
!
!  Surface eastward wind stress component (m2 s-2). Imported stress
!  component is at RHO-points.
!
            CASE ('taux', 'sustr')
              IF (.not.allocated(ustress)) THEN
                allocate ( ustress(lbi:ubi,lbj:ubj) )
                ustress=missing_dp
              END IF
              got_stress(1)=.true.
              romsscale=stressscale
              ifield=idusms
              gtype=u2dvar
              tindex=3-iinfo(8,ifield,ng)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),fval)
                  myfmax(1)=max(myfmax(1),fval)
                  fval=fval*romsscale
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
#  ifdef TIME_INTERP
                  forces(ng)%sustrG(i,j,tindex)=fval
#  else
                  ustress(i,j)=fval
#  endif
                END DO
              END DO
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    ustress)
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              ustress)
              END IF
# endif
# if !defined BULK_FLUXES
!
!  Surface northward wind stress component (m2 s-2). Imported stress
!  component is at RHO-points.
!
            CASE ('tauy', 'svstr')
              IF (.not.allocated(vstress)) THEN
                allocate ( vstress(lbi:ubi,lbj:ubj) )
                vstress=missing_dp
              END IF
              got_stress(2)=.true.
              romsscale=stressscale
              ifield=idvsms
              gtype=v2dvar
              tindex=3-iinfo(8,ifield,ng)
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),fval)
                  myfmax(1)=max(myfmax(1),fval)
                  fval=fval*romsscale
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
#  ifdef TIME_INTERP
                  forces(ng)%svstrG(i,j,tindex)=fval
#  else
                  vstress(i,j)=fval
#  endif
                END DO
              END DO
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    vstress)
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              vstress)
              END IF
# endif
# if defined WIND_MINUS_CURRENT && !defined BULK_FLUXES
!
!  Surface air density (kg/m3).
!
            CASE ('RhoAir')
              IF (.not.allocated(rhoair)) THEN
                allocate ( rhoair(lbi:ubi,lbj:ubj) )
                rhoair=missing_dp
              END IF
              got_rhoair=.true.
              romsscale=scale
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),fval)
                  myfmax(1)=max(myfmax(1),fval)
                  fval=fval*romsscale
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
                  rhoair(i,j)=fval
                END DO
              END DO
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    rhoair)
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              rhoair)
              END IF
!
!  Eastward wind component (m s-1) at surface boundary layer. Imported
!  wind component is at RHO-points.
!
            CASE ('Uwind_sbl')
              IF (.not.allocated(xwind)) THEN
                allocate ( xwind(lbi:ubi,lbj:ubj) )
                xwind=missing_dp
              END IF
              got_wind_sbl(1)=.true.
              romsscale=scale
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),ptr2d(i,j))
                  myfmax(1)=max(myfmax(1),ptr2d(i,j))
                  fval=fval*romsscale
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
                  xwind(i,j)=fval
                END DO
              END DO
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    xwind)
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              xwind)
              END IF
!
!  Northward wind component (m s-1) at surface boundary layer. Imported
!  wind component is at RHO-points.
!
            CASE ('Vwind_sbl')
              IF (.not.allocated(ywind)) THEN
                allocate ( ywind(lbi:ubi,lbj:ubj) )
                ywind=missing_dp
              END IF
              got_wind_sbl(2)=.true.
              romsscale=scale
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),ptr2d(i,j))
                  myfmax(1)=max(myfmax(1),ptr2d(i,j))
                  fval=fval*romsscale
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
                  ywind(i,j)=fval
                END DO
              END DO
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    ywind)
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              ywind)
              END IF
!
!  Surface frictional wind magnitude (m s-1) from similarity theory.
!  Imported wind magnitude is at RHO-points.
!
            CASE ('Wstar')
              IF (.not.allocated(wstar)) THEN
                allocate ( wstar(lbi:ubi,lbj:ubj) )
                wstar=missing_dp
              END IF
              got_wstar=.true.
              romsscale=scale
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (abs(ptr2d(i,j)).lt.tol_dp) THEN
                    fval=scale*ptr2d(i,j)+add_offset
                  ELSE
                    fval=0.0_dp
                  END IF
                  myfmin(1)=min(myfmin(1),ptr2d(i,j))
                  myfmax(1)=max(myfmax(1),ptr2d(i,j))
                  fval=fval*romsscale
                  myfmin(2)=min(myfmin(2),fval)
                  myfmax(2)=max(myfmax(2),fval)
                  wstar(i,j)=fval
                END DO
              END DO
              IF (localde.eq.localdecount-1) THEN
                IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
                  CALL exchange_r2d_tile (ng, tile,                     &
     &                                    lbi, ubi, lbj, ubj,           &
     &                                    wstar)
                END IF
                CALL mp_exchange2d (ng, tile, inlm, 1,                  &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              nghostpoints,                       &
     &                              ewperiodic(ng), nsperiodic(ng),     &
     &                              wstar)
              END IF
#  endif
!
!  Import field not found.
!
            CASE DEFAULT
              IF (localpet.eq.0) THEN
                WRITE (cplout,10) trim(importnamelist(ifld)),           &
     &                            trim(time_currentstring),             &
     &                            trim(cplname)
              END IF
              exit_flag=9
              IF (founderror(exit_flag, noerror, __line__,              &
     &                     myfile)) THEN
                rc=esmf_rc_not_found
                RETURN
              END IF
          END SELECT
!
!  Print pointer information.
!
          IF (debuglevel.eq.4) THEN
            WRITE (cplout,20) localpet, localde,                        &
     &                        lbound(ptr2d,dim=1), ubound(ptr2d,dim=1), &
     &                        lbound(ptr2d,dim=2), ubound(ptr2d,dim=2), &
     &                        istrr, iendr, jstrr, jendr
          END IF
!
!  Nullify pointer to make sure that it does not point on a random
!  part in the memory.
!
          IF (associated(ptr2d)) nullify (ptr2d)
        END DO de_loop
!
!  Get import field minimun and maximum values.
!
        CALL esmf_vmallreduce (vm,                                      &
     &                         senddata=myfmin,                         &
     &                         recvdata=fmin,                           &
     &                         count=2,                                 &
     &                         reduceflag=esmf_reduce_min,              &
     &                         rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
!
        CALL esmf_vmallreduce (vm,                                      &
     &                         senddata=myfmax,                         &
     &                         recvdata=fmax,                           &
     &                         count=2,                                 &
     &                         reduceflag=esmf_reduce_max,              &
     &                         rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
!
!  Write out import field information.
!
        IF ((debuglevel.ge.0).and.(localpet.eq.0)) THEN
          WRITE (cplout,30) trim(importnamelist(ifld)),                 &
# ifdef TIME_INTERP
     &                      trim(mydate(tindex)), ng,                   &
     &                      fmin(1), fmax(1), tindex
# else
     &                      trim(time_currentstring), ng,               &
     &                      fmin(1), fmax(1)
# endif
          IF (romsscale.ne.1.0_dp) THEN
            WRITE (cplout,40) fmin(2), fmax(2),                         &
     &                        ' romsScale = ', romsscale
          ELSE IF (add_offset.ne.0.0_dp) THEN
            WRITE (cplout,40) fmin(2), fmax(2),                         &
     &                        ' AddOffset = ', add_offset
          END IF
        END IF
 
# ifdef TIME_INTERP
!
!  Load ROMS metadata information needed for time interpolation and
!  reporting.
!
        IF (loadit) THEN
          linfo(1,ifield,ng)=.true.                          ! Lgrided
          linfo(3,ifield,ng)=.false.                         ! Lonerec
          iinfo(1,ifield,ng)=gtype
          iinfo(8,ifield,ng)=tindex
          finfo(1,ifield,ng)=tmin
          finfo(2,ifield,ng)=tmax
          finfo(3,ifield,ng)=tstr
          finfo(4,ifield,ng)=tend
          finfo(8,ifield,ng)=fmin(1)
          finfo(9,ifield,ng)=fmax(1)
          vtime(tindex,ifield,ng)=myvtime(tindex)
          tintrp(tindex,ifield,ng)=mytintrp(tindex)*86400.0_dp
        END IF
# endif
!
!  Debugging: write out import field into NetCDF file.
!
        IF ((debuglevel.ge.3).and.                                      &
     &      models(iroms)%ImportField(id)%debug_write) THEN
          WRITE (ofile,50) ng, trim(importnamelist(ifld)),              &
     &                     year, month, day, hour, minutes, seconds
          CALL esmf_fieldwrite (field,                                  &
     &                          trim(ofile),                            &
     &                          overwrite=.true.,                       &
     &                          rc=rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
        END IF
 
      END DO fld_loop
 
# if defined BULK_FLUXES || defined ECOSIM
!
!  If applicable, rotate wind components to ROMS curvilinear grid.
!
      IF (got_wind(1).and.got_wind(2)) THEN
        CALL roms_rotate (ng, tile, geo2grid_rho,                       &
     &                    lbi, ubi, lbj, ubj,                           &
     &                    uwind, vwind,                                 &
     &                    forces(ng)%Uwind, forces(ng)%Vwind)
        deallocate (uwind)
        deallocate (vwind)
      END IF
#  endif
#  if !defined BULK_FLUXES
!
!  If applicable, rotate wind stress components to ROMS curvilinear
!  grid.
!
      IF (got_stress(1).and.got_stress(2)) THEN
        CALL roms_rotate (ng, tile, geo2grid,                            &
     &                    lbi, ubi, lbj, ubj,                            &
     &                    ustress, vstress,                              &
     &                    forces(ng)%sustr, forces(ng)%svstr)
        deallocate (ustress)
        deallocate (vstress)
      END IF
# endif
# if defined WIND_MINUS_CURRENT && !defined BULK_FLUXES
!
!  If applicable, compute surface wind stress components. The surface
!  ocean currents are substracted to the wind.
!
!  The wind stress component are computed as:
!
!          taux/rho0 = RhoAir * Cd * Wrel * Urel
!          tauy/rho0 = RhoAir * Cd * Wrel * Vrel
!  where
!          Cd = Wstr**2 / Wmag**2
!
!  so the magnitude is diminished by the weaker relative (wind minus
!  current) components. The coupling is incompleate becasue there is
!  not feeback to the atmosphere (wind is not modified by currents).
!
      myfmin= missing_dp
      myfmax=-missing_dp
!
      IF (got_rhoair.and.got_wstar.and.                                 &
     &    got_wind_sbl(1).and.got_wind_sbl(2)) THEN
        IF (.not.allocated(uwrk)) THEN
          allocate ( uwrk(lbi:ubi,lbj:ubj) )
          uwrk=missing_dp
        END IF
        IF (.not.allocated(vwrk)) THEN
          allocate ( vwrk(lbi:ubi,lbj:ubj) )
          vwrk=missing_dp
        END IF
!
        CALL roms_rotate (ng, tile, grid2geo_rho,                       &
     &                    lbi, ubi, lbj, ubj,                           &
     &                    ocean(ng)%u(:,:,n(ng),nstp(ng)),              &
     &                    ocean(ng)%v(:,:,n(ng),nstp(ng)),              &
     &                    uwrk, vwrk)         ! rotated currents to E-N
!
        DO j=jstr-1,jend+1
          DO i=istr-1,iend+1
            romsscale=stressscale                   ! m3/kg
            urel=xwind(i,j)-uwrk(i,j)               ! relative wind:
            vrel=ywind(i,j)-vwrk(i,j)               ! wind minus current
            wmag=sqrt(xwind(i,j)*xwind(i,j)+                            &
     &                ywind(i,j)*ywind(i,j))        ! ATM wind magnitude
            wrel=sqrt(urel*urel+vrel*vrel)          ! relative magmitude
            cff1=romsscale*rhoair(i,j)
            cff2=wstar(i,j)*wstar(i,j)/(wmag*wmag+eps)
            cff3=cff1*cff2*wrel                     ! m/s
            uwrk(i,j)=cff3*urel                     ! m2/s2
            vwrk(i,j)=cff3*vrel                     ! m2/s2
            myfmin(1)=min(myfmin(1),uwrk(i,j))
            myfmin(2)=min(myfmin(2),vwrk(i,j))
            myfmax(1)=max(myfmax(1),uwrk(i,j))
            myfmax(2)=max(myfmax(2),vwrk(i,j))
          END DO
        END DO
        deallocate (rhoair)
        deallocate (wstar)
        deallocate (xwind)
        deallocate (ywind)
!                                            ! rotate stress to grid
        CALL roms_rotate (ng, tile, geo2grid,                           &
     &                    lbi, ubi, lbj, ubj,                           &
     &                    uwrk, vwrk,                                   &
     &                    forces(ng)%sustr,                             &
     &                    forces(ng)%svstr)
        deallocate (uwrk)
        deallocate (vwrk)
!
!  Report computed wind stress minimum and maximum values.
!
        IF (debuglevel.ge.0) THEN
          CALL esmf_vmallreduce (vm,                                    &
     &                           senddata=myfmin,                       &
     &                           recvdata=fmin,                         &
     &                           count=2,                               &
     &                           reduceflag=esmf_reduce_min,            &
     &                           rc=rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
!
          CALL esmf_vmallreduce (vm,                                    &
     &                           senddata=myfmax,                       &
     &                           recvdata=fmax,                         &
     &                           count=2,                               &
     &                           reduceflag=esmf_reduce_max,            &
     &                           rc=rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
!
          IF (localpet.eq.0) THEN
            WRITE (cplout,60) 'sustr',                                  &
     &                        trim(time_currentstring), ng,             &
     &                        fmin(1)/stressscale,                      &
     &                        fmax(1)/stressscale
            WRITE (cplout,40) fmin(1), fmax(1),                         &
     &                        ' romsScale = ', stressscale
!
            WRITE (cplout,60) 'svstr',                                  &
     &                        trim(time_currentstring), ng,             &
     &                        fmin(2)/stressscale,                      &
     &                        fmax(2)/stressscale
            WRITE (cplout,40) fmin(2), fmax(2),                         &
     &                        ' romsScale = ', stressscale
          END IF
        END IF
      END IF
# endif
!
!  Deallocate local arrays.
!
      IF (allocated(importnamelist)) deallocate (importnamelist)
!
!  Update ROMS import calls counter.
!
      IF (importcount.gt.0) THEN
        models(iroms)%ImportCalls=models(iroms)%ImportCalls+1
      END IF
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '<== Exiting  ROMS_Import',             &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      IF (debuglevel.gt.0) FLUSH (cplout)
!
  10  FORMAT (/,3x,' ROMS_Import - unable to find option to import: ',  &
     &        a,t72,a,/,18x,'check ''Import(roms)'' in input script: ', &
     &        a)
  20  FORMAT (18x,'PET/DE [',i3.3,'/',i2.2,'],  Pointer Size: ',4i8,    &
     &        /,36x,'Tiling Range: ',4i8)
  30  FORMAT (3x,' ROMS_Import - ESMF: importing field ''',a,'''',      &
     &        t72,a,2x,'Grid ',i2.2,                                    &
# ifdef TIME_INTERP
     &        /,19x,'(InpMin = ', 1p,e15.8,0p,' InpMax = ',1p,e15.8,0p, &
     &        '  SnapshotIndex = ',i1,')')
# else
     &        /,19x,'(InpMin = ', 1p,e15.8,0p,' InpMax = ',1p,e15.8,0p, &
     &        ')')
# endif
  40  FORMAT (19x,'(OutMin = ', 1p,e15.8,0p,' OutMax = ',1p,e15.8,0p,   &
     &        1x,a,1p,e15.8,0p,')')
  50  FORMAT ('roms_',i2.2,'_import_',a,'_',i4.4,2('-',i2.2),'_',       &
     &        i2.2,2('.',i2.2),'.nc')
  60  FORMAT (3x,' ROMS_Import - ESMF: computing field ''',a,'''',      &
     &        t72,a,2x,'Grid ',i2.2,                                    &
     &        /,19x,'(InpMin = ', 1p,e15.8,0p,' InpMax = ',1p,e15.8,0p, &
     &        ')')
!
      RETURN
      END SUBROUTINE roms_import
!
      SUBROUTINE roms_export (ng, model, rc)
!
!=======================================================================
!                                                                      !
!  Exports ROMS fields to other coupled gridded components.            !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(in)  :: ng
      integer, intent(out) :: rc
!
      TYPE (esmf_gridcomp) :: model
!
!  Local variable declarations.
!
      logical :: get_barotropic
      logical :: get_surfacecurrent
!
      integer :: istr,  iend,  jstr,  jend
      integer :: istrr, iendr, jstrr, jendr
      integer :: lbi, ubi, lbj, ubj
      integer :: exportcount
      integer :: localde, localdecount, localpet, tile
      integer :: year, month, day, hour, minutes, seconds, sn, sd
      integer :: ifld, i, is, j
!
      real (dp) :: fmin(1), fmax(1), fval, myfmin(1), myfmax(1)
!
      real (dp), pointer :: ptr2d(:,:) => null()
!
      real (dp), allocatable  :: ubar(:,:), vbar(:,:)
      real (dp), allocatable  :: usur(:,:), vsur(:,:)
!
      character (len=22)      :: time_currentstring
 
      character (len=:), allocatable :: fldname
 
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", ROMS_Export"
 
      character (ESMF_MAXSTR) :: cname, ofile
      character (ESMF_MAXSTR), allocatable :: exportnamelist(:)
!
      TYPE (esmf_field) :: field
      TYPE (esmf_time)  :: currenttime
      TYPE (esmf_vm)    :: vm
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '==> Entering ROMS_Export',             &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  Get information about the gridded component.
!-----------------------------------------------------------------------
!
      CALL esmf_gridcompget (model,                                     &
     &                       localpet=localpet,                         &
     &                       vm=vm,                                     &
     &                       name=cname,                                &
     &                       rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Get number of local decomposition elements (DEs). Usually, a single
!  DE is associated with each Persistent Execution Thread (PETs). Thus,
!  localDEcount=1.
!
      CALL esmf_gridget (models(iroms)%grid(ng),                        &
     &                   localdecount=localdecount,                     &
     &                   rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!  Set horizontal tile bounds.
!
      tile=localpet
!
      lbi=bounds(ng)%LBi(tile)       ! lower bound I-direction
      ubi=bounds(ng)%UBi(tile)       ! upper bound I-direction
      lbj=bounds(ng)%LBj(tile)       ! lower bound J-direction
      ubj=bounds(ng)%UBj(tile)       ! upper bound J-direction
!
      istrr=bounds(ng)%IstrR(tile)   ! Full range I-starting (RHO)
      iendr=bounds(ng)%IendR(tile)   ! Full range I-ending   (RHO)
      jstrr=bounds(ng)%JstrR(tile)   ! Full range J-starting (RHO)
      jendr=bounds(ng)%JendR(tile)   ! Full range J-ending   (RHO)
!
      istr=bounds(ng)%Istr(tile)     ! Full range I-starting (PSI, U)
      iend=bounds(ng)%Iend(tile)     ! Full range I-ending   (PSI)
      jstr=bounds(ng)%Jstr(tile)     ! Full range J-starting (PSI, V)
      jend=bounds(ng)%Jend(tile)     ! Full range J-ending   (PSI)
!
!-----------------------------------------------------------------------
!  Get current time.
!-----------------------------------------------------------------------
!
      CALL esmf_clockget (clockinfo(iroms)%Clock,                       &
     &                    currtime=currenttime,                         &
     &                    rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      CALL esmf_timeget (currenttime,                                   &
     &                   yy=year,                                       &
     &                   mm=month,                                      &
     &                   dd=day,                                        &
     &                   h =hour,                                       &
     &                   m =minutes,                                    &
     &                   s =seconds,                                    &
     &                   sn=sn,                                         &
     &                   sd=sd,                                         &
     &                   timestring=time_currentstring,                 &
     &                   rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
      is=index(time_currentstring, 'T')              ! remove 'T' in
      IF (is.gt.0) time_currentstring(is:is)=' '     ! ISO 8601 format
!
!-----------------------------------------------------------------------
!  Get list of export fields.
!-----------------------------------------------------------------------
!
      CALL esmf_stateget (models(iroms)%ExportState(ng),                &
     &                    itemcount=exportcount,                        &
     &                    rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      IF (.not. allocated(exportnamelist)) THEN
        allocate ( exportnamelist(exportcount) )
      END IF
!
      CALL esmf_stateget (models(iroms)%ExportState(ng),                &
     &                    itemnamelist=exportnamelist,                  &
     &                    rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Load export fields.
!-----------------------------------------------------------------------
!
      get_barotropic=.true.
      get_surfacecurrent=.true.
!
      fld_loop : DO ifld=1,exportcount
!
!   Get field from export state.
!
        CALL esmf_stateget (models(iroms)%ExportState(ng),              &
     &                      trim(exportnamelist(ifld)),                 &
     &                      field,                                      &
     &                      rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
!
!  Skip if it is scalar field.
!
        IF (trim(exportnamelist(ifld)) == trim(scalarfieldname)) THEN
          cycle
        END IF
!
!  Get field pointer.  Usually, the DO-loop is executed once since
!  localDEcount=1.
!
        de_loop : DO localde=0,localdecount-1
          CALL esmf_fieldget (field,                                    &
     &                        localde=localde,                          &
     &                        farrayptr=ptr2d,                          &
     &                        rc=rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
!
!  Initialize pointer to missing value.
!
          ptr2d=missing_dp
!
!  Load field data into export state. Notice that all export fields
!  are kept as computed by ROMS. The imported component does the
!  proper scaling, physical units conversion, and other manipulations.
!  It is done to avoid applying such transformations twice.
!
          SELECT CASE (trim(adjustl(exportnamelist(ifld))))
!
!  Sea surface temperature (C).
# if defined EXCLUDE_SPONGE && \
    (defined data_coupling  && !defined ANA_SPONGE)
!  If using a diffusion sponge, remove the SST points in the sponge area
!  to supress the spurious influence of open boundary conditions in the
!  computation of the net heat flux. The SST values in the sponge are
!  from the large scale DATA component in the merged ocean/data field
!  imported by the atmosphere model.
# endif
!
            CASE ('sst', 'SST')
              myfmin(1)= missing_dp
              myfmax(1)=-missing_dp
              DO j=jstrr,jendr
                DO i=istrr,iendr
# if defined EXCLUDE_SPONGE && \
    (defined data_coupling  && !defined ANA_SPONGE)
                  IF (ltracersponge(itemp,ng).and.                      &
     &                mixing(ng)%diff_factor(i,j).gt.1.0_dp) THEN
                    fval=missing_dp
                  ELSE
                    fval=ocean(ng)%t(i,j,n(ng),nstp(ng),itemp)
#  ifdef MASKING
                    IF (grid(ng)%rmask(i,j).gt.0.0_r8) THEN
                      myfmin(1)=min(myfmin(1),fval)
                      myfmax(1)=max(myfmax(1),fval)
                    END IF
#  else
                    myfmin(1)=min(myfmin(1),fval)
                    myfmax(1)=max(myfmax(1),fval)
#  endif
                  END IF
# else
                  fval=ocean(ng)%t(i,j,n(ng),nstp(ng),itemp)
#  ifdef MASKING
                  IF (grid(ng)%rmask(i,j).gt.0.0_r8) THEN
                    myfmin(1)=min(myfmin(1),fval)
                    myfmax(1)=max(myfmax(1),fval)
                  END IF
#  else
                  myfmin(1)=min(myfmin(1),fval)
                  myfmax(1)=max(myfmax(1),fval)
#  endif
# endif
                  ptr2d(i,j)=fval
                END DO
              END DO
!
!  Sea surface height (m).
!
            CASE ('ssh', 'SSH')
              myfmin(1)=1.0_dp
              myfmax(1)=0.0_dp
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  fval=ocean(ng)%zeta(i,j,knew(ng))
# ifdef MASKING
                  IF (grid(ng)%rmask(i,j).gt.0.0_r8) THEN
                    myfmin(1)=min(myfmin(1),fval)
                    myfmax(1)=max(myfmax(1),fval)
                  END IF
# else
                  myfmin(1)=min(myfmin(1),fval)
                  myfmax(1)=max(myfmax(1),fval)
# endif
                  ptr2d(i,j)=fval
                END DO
              END DO
!
!  Depth-integrated (barotropic) currents (m/s) at interior RHO-points
!  (East/North direction).
!
            CASE ('Ubar', 'Vbar')
              IF (founderror(assign_string(fldname,                     &
     &                                     exportnamelist(ifld)),       &
     &            noerror, __line__, myfile)) THEN
                rc=esmf_rc_not_found
                RETURN
              END IF
!
              IF (get_barotropic) THEN
                get_barotropic=.false.
                IF (.not.allocated(ubar)) THEN
                  allocate ( ubar(lbi:ubi,lbj:ubj) )
                  ubar=missing_dp
                END IF
                IF (.not.allocated(vbar)) THEN
                  allocate ( vbar(lbi:ubi,lbj:ubj) )
                  vbar=missing_dp
                END IF
                CALL roms_rotate (ng, tile, grid2geo_rho,               &
     &                            lbi, ubi, lbj, ubj,                   &
     &                            ocean(ng)%ubar(:,:,knew(ng)),         &
     &                            ocean(ng)%vbar(:,:,knew(ng)),         &
     &                            ubar, vbar)
              END IF
!
              IF (fldname.eq.'Ubar') THEN
                DO j=jstr,jend
                  DO i=istr,iend
                    fval=ubar(i,j)
                    myfmin(1)=min(myfmin(1),fval)
                    myfmax(1)=max(myfmax(1),fval)
                    ptr2d(i,j)=fval
                  END DO
                END DO
                deallocate (ubar)
              ELSE
                DO j=jstr,jend
                  DO i=istr,iend
                    fval=vbar(i,j)
                    myfmin(1)=min(myfmin(1),fval)
                    myfmax(1)=max(myfmax(1),fval)
                    ptr2d(i,j)=fval
                  END DO
                END DO
                deallocate (vbar)
              END IF
!
!  Surface currents (m/s) at interior RHO-points (East/North direction).
!
            CASE ('Usur', 'Vsur')
              IF (founderror(assign_string(fldname,                     &
     &                                     exportnamelist(ifld)),       &
     &            noerror, __line__, myfile)) THEN
                rc=esmf_rc_not_found
                RETURN
              END IF
!
              IF (get_surfacecurrent) THEN
                get_surfacecurrent=.false.
                IF (.not.allocated(ubar)) THEN
                  allocate ( usur(lbi:ubi,lbj:ubj) )
                  usur=missing_dp
                END IF
                IF (.not.allocated(vbar)) THEN
                  allocate ( vsur(lbi:ubi,lbj:ubj) )
                  vsur=missing_dp
                END IF
                CALL roms_rotate (ng, tile, grid2geo_rho,              &
     &                            lbi, ubi, lbj, ubj,                  &
     &                            ocean(ng)%u(:,:,n(ng),nstp(ng)),     &
     &                            ocean(ng)%v(:,:,n(ng),nstp(ng)),     &
     &                            usur, vsur)
              END IF
!
              IF (fldname.eq.'Usur') THEN
                DO j=jstr,jend
                  DO i=istr,iend
                    fval=usur(i,j)
                    myfmin(1)=min(myfmin(1),fval)
                    myfmax(1)=max(myfmax(1),fval)
                    ptr2d(i,j)=fval
                  END DO
                END DO
                deallocate (usur)
              ELSE
                DO j=jstr,jend
                  DO i=istr,iend
                    fval=vsur(i,j)
                    myfmin(1)=min(myfmin(1),fval)
                    myfmax(1)=max(myfmax(1),fval)
                    ptr2d(i,j)=fval
                  END DO
                END DO
                deallocate (vsur)
              END IF
!
!  Bathymetry (m). It can be time dependent due sediment morphology.
!
            CASE ('bath')
              myfmin(1)=1.0_dp
              myfmax(1)=0.0_dp
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  fval=grid(ng)%h(i,j)
                  myfmin(1)=min(myfmin(1),fval)
                  myfmax(1)=max(myfmax(1),fval)
                  ptr2d(i,j)=fval
                END DO
              END DO
 
# if defined MASKING
!
!  Update wet point land/sea mask, if differs from static mask.
!
            CASE ('mask_rho', 'rmask', 'msk')
              myfmin(1)=1.0_dp
              myfmax(1)=0.0_dp
              DO j=jstrr,jendr
                DO i=istrr,iendr
                  IF (grid(ng)%rmask(i,j).gt.0.0_r8) THEN
# ifdef WET_DRY
                    IF (grid(ng)%rmask(i,j).ne.                         &
     &                  grid(ng)%rmask_wet(i,j)) THEN
                      ptr2d(i,j)=grid(ng)%rmask_wet(i,j)
                    ELSE
                      ptr2d(i,j)=grid(ng)%rmask(i,j)
                    END IF
# else
                    ptr2d(i,j)=grid(ng)%rmask(i,j)
# endif
                    myfmin(1)=min(myfmin(1),ptr2d(i,j))
                    myfmax(1)=max(myfmax(1),ptr2d(i,j))
                  END IF
                END DO
              END DO
# endif
!
!  Export field not found.
!
            CASE DEFAULT
              IF (localpet.eq.0) THEN
                WRITE (cplout,10) trim(adjustl(exportnamelist(ifld))),  &
     &                            trim(cplname)
              END IF
              rc=esmf_rc_not_found
              IF (esmf_logfounderror(rctocheck=rc,                      &
     &                               msg=esmf_logerr_passthru,          &
     &                               line=__line__,                     &
     &                               file=myfile)) THEN
                RETURN
              END IF
          END SELECT
!
!  Nullify pointer to make sure that it does not point on a random
!  part in the memory.
!
          IF (associated(ptr2d)) nullify (ptr2d)
        END DO de_loop
!
!  Get export field minimun and maximum values.
!
        CALL esmf_vmallreduce (vm,                                      &
     &                         senddata=myfmin,                         &
     &                         recvdata=fmin,                           &
     &                         count=1,                                 &
     &                         reduceflag=esmf_reduce_min,              &
     &                         rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
!
        CALL esmf_vmallreduce (vm,                                      &
     &                         senddata=myfmax,                         &
     &                         recvdata=fmax,                           &
     &                         count=1,                                 &
     &                         reduceflag=esmf_reduce_max,              &
     &                         rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
!
        IF (localpet.eq.0) THEN
          WRITE (cplout,20) trim(exportnamelist(ifld)),                 &
     &                      trim(time_currentstring), ng,               &
     &                      fmin(1), fmax(1)
        END IF
!
!  Debugging: write out field into a NetCDF file.
!
        IF ((debuglevel.ge.3).and.                                      &
     &      models(iroms)%ExportField(ifld)%debug_write) THEN
          WRITE (ofile,30) ng, trim(exportnamelist(ifld)),              &
                           year, month, day, hour, minutes, seconds
          CALL esmf_fieldwrite (field,                                  &
     &                          trim(ofile),                            &
     &                          overwrite=.true.,                       &
     &                          rc=rc)
          IF (esmf_logfounderror(rctocheck=rc,                          &
     &                           msg=esmf_logerr_passthru,              &
     &                           line=__line__,                         &
     &                           file=myfile)) THEN
            RETURN
          END IF
        END IF
      END DO fld_loop
!
!  Deallocate local arrays.
!
      IF (allocated(exportnamelist)) deallocate (exportnamelist)
!
!  Update ROMS export calls counter.
!
      IF (exportcount.gt.0) THEN
        models(iroms)%ExportCalls=models(iroms)%ExportCalls+1
      END IF
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '<== Exiting  ROMS_Export',             &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
      FLUSH (cplout)
!
  10  FORMAT (/,3x,' ROMS_Export - unable to find option to export: ',  &
     &        a,/,18x,'check ''Export(roms)'' in input YAML: ',a)
  20  FORMAT (3x,' ROMS_Export - ESMF:  exporting field ''',a,'''',     &
     &        t72,a,2x,'Grid ',i2.2,/,                                  &
     &        18x,'(OutMin = ', 1p,e15.8,0p,' OutMax = ',1p,e15.8,0p,   &
     &        ')')
  30  FORMAT ('roms_',i2.2,'_export_',a,'_',i4.4,2('-',i2.2),'_',       &
     &        i2.2,2('.',i2.2),'.nc')
 
      RETURN
      END SUBROUTINE roms_export
!
      SUBROUTINE roms_rotate (ng, tile, Lrotate,                        &
     &                        LBi, UBi, LBj, UBj,                       &
     &                        Uinp, Vinp,                               &
     &                        Uout, Vout)
!
!=======================================================================
!                                                                      !
!  It rotates exchanged vector components from computational grid to   !
!  geographical EAST and NORTH directions or vice versa acccording to  !
!  Lrotate flag:                                                       !
!                                                                      !
!    Lrotate =  geo2grid_rho       RHO-points rotation                 !
!    Lrotate =  grid2geo_rho       Exporting interior RHO-points       !
!    Lrotate =  geo2grid           U- and V-points staggered rotation  !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(in)  :: ng, tile, lrotate
      integer, intent(in)  :: lbi, ubi, lbj, ubj
!
      real (dp), intent(in)  :: uinp(lbi:ubi,lbj:ubj)
      real (dp), intent(in)  :: vinp(lbi:ubi,lbj:ubj)
      real (r8), intent(out) :: uout(lbi:ubi,lbj:ubj)
      real (r8), intent(out) :: vout(lbi:ubi,lbj:ubj)
!
!  Local variable declarations.
!
      integer :: i, j
      integer :: istrr, iendr, jstrr, jendr
      integer :: istr, iend, jstr, jend
!
      real :: urho, vrho
!
      real (r8) :: urot(lbi:ubi,lbj:ubj)
      real (r8) :: vrot(lbi:ubi,lbj:ubj)
!
!-----------------------------------------------------------------------
!  Initialize.
!-----------------------------------------------------------------------
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '==> Entering ROMS_Rotate',             &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
!
!  Set horizontal tile bounds.
!
      istrr=bounds(ng)%IstrR(tile)   ! Full range I-starting (RHO)
      iendr=bounds(ng)%IendR(tile)   ! Full range I-ending   (RHO)
      jstrr=bounds(ng)%JstrR(tile)   ! Full range J-starting (RHO)
      jendr=bounds(ng)%JendR(tile)   ! Full range J-ending   (RHO)
!
      istr=bounds(ng)%Istr(tile)     ! Full range I-starting (PSI, U)
      iend=bounds(ng)%Iend(tile)     ! Full range I-ending   (PSI)
      jstr=bounds(ng)%Jstr(tile)     ! Full range J-starting (PSI, V)
      jend=bounds(ng)%Jend(tile)     ! Full range J-ending   (PSI)
 
# ifdef CURVGRID
!
!-----------------------------------------------------------------------
!  Rotate from geographical (EAST, NORTH) to computational grid
!  directions (ROMS import case).
!-----------------------------------------------------------------------
!
      IF ((lrotate.eq.geo2grid).or.(lrotate.eq.geo2grid_rho)) THEN
        DO j=jstrr,jendr
          DO i=istrr,iendr
            urot(i,j)=uinp(i,j)*grid(ng)%CosAngler(i,j)+                &
     &                vinp(i,j)*grid(ng)%SinAngler(i,j)
            vrot(i,j)=vinp(i,j)*grid(ng)%CosAngler(i,j)-                &
     &                uinp(i,j)*grid(ng)%SinAngler(i,j)
          END DO
        END DO
!
!  There is an option to import the rotated vector to staggered U- and
!  V-locations (arithmetic avererage) or import vector at its native
!  cell center (RHO-points).
!
        IF (lrotate.eq.geo2grid_rho) THEN             ! RHO-points
          DO j=jstrr,jendr
            DO i=istrr,iendr
              uout(i,j)=urot(i,j)
              vout(i,j)=vrot(i,j)
            END DO
          END DO
!
          IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
            CALL exchange_r2d_tile (ng, tile,                           &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              uout)
            CALL exchange_r2d_tile (ng, tile,                           &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              vout)
          END IF
 
        ELSE IF (lrotate.eq.geo2grid) THEN            ! U- and V-points
          DO j=jstrr,jendr
            DO i=istr,iendr
              uout(i,j)=0.5_r8*(urot(i-1,j)+urot(i,j))
#  ifdef MASKING
              uout(i,j)=uout(i,j)*grid(ng)%umask(i,j)
#  endif
#  ifdef WET_DRY
              uout(i,j)=uout(i,j)*grid(ng)%umask_wet(i,j)
#  endif
            END DO
          END DO
          DO j=jstr,jendr
            DO i=istrr,iendr
              vout(i,j)=0.5_r8*(vrot(i,j-1)+vrot(i,j))
#  ifdef MASKING
              vout(i,j)=vout(i,j)*grid(ng)%vmask(i,j)
#  endif
#  ifdef WET_DRY
              vout(i,j)=vout(i,j)*grid(ng)%vmask_wet(i,j)
#  endif
            END DO
          END DO
 
          IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
            CALL exchange_u2d_tile (ng, tile,                           &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              uout)
            CALL exchange_v2d_tile (ng, tile,                           &
     &                              lbi, ubi, lbj, ubj,                 &
     &                              vout)
          END IF
        END IF
!
!-----------------------------------------------------------------------
!  Rotate from computational grid to geographical (EAST, NORTH)
!  directions (ROMS Export case: vector at RHO-points).
!-----------------------------------------------------------------------
!
      ELSE IF (lrotate.eq.grid2geo_rho) THEN
        uout=0.0_r8
        vout=0.0_r8
        DO j=jstr,jend
          DO i=istr,iend
            urho=0.5_r8*(uinp(i,j)+uinp(i+1,j))
            vrho=0.5_r8*(vinp(i,j)+vinp(i,j+1))
            uout(i,j)=urho*grid(ng)%CosAngler(i,j)-                     &
     &                vrho*grid(ng)%SinAngler(i,j)
            vout(i,j)=vrho*grid(ng)%CosAngler(i,j)+                     &
     &                urho*grid(ng)%SinAngler(i,j)
#  ifdef MASKING
            uout(i,j)=uout(i,j)*grid(ng)%rmask(i,j)
            vout(i,j)=vout(i,j)*grid(ng)%rmask(i,j)
#  endif
#  ifdef WET_DRY
            uout(i,j)=uout(i,j)*grid(ng)%rmask_wet(i,j)
            vout(i,j)=vout(i,j)*grid(ng)%rmask_wet(i,j)
#  endif
          END DO
        END DO
!
        CALL bc_r2d_tile (ng, tile,                                     &
     &                    lbi, ubi, lbj, ubj,                           &
     &                    uout)
        CALL bc_r2d_tile (ng, tile,                                     &
     &                    lbi, ubi, lbj, ubj,                           &
     &                    vout)
!
        IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
          CALL exchange_r2d_tile (ng, tile,                             &
     &                            lbi, ubi, lbj, ubj,                   &
     &                            uout)
          CALL exchange_r2d_tile (ng, tile,                             &
     &                            lbi, ubi, lbj, ubj,                   &
     &                            vout)
        END IF
      END IF
# else
!
!-----------------------------------------------------------------------
!  Otherwise, load unrotated components to staggered location. ROMS grid
!  is not curvilinear (ROMS import case). It is very unlikely to have
!  realistic applications that are not curvilinear and rotated).
!-----------------------------------------------------------------------
!
      IF (lrotate.eq.geo2grid_rho) THEN               ! RHO-points
        DO j=jstrr,jendr
          DO i=istrr,iendr
            uout(i,j)=uinp(i,j)
            vout(i,j)=vinp(i,j)
          END DO
        END DO
!
        IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
          CALL exchange_r2d_tile (ng, tile,                             &
     &                            lbi, ubi, lbj, ubj,                   &
     &                            uout)
          CALL exchange_r2d_tile (ng, tile,                             &
     &                            lbi, ubi, lbj, ubj,                   &
     &                            vout)
        END IF
 
      ELSE IF (lrotate.eq.geo2grid) THEN              ! U- and V-points
        DO j=jstrr,jendr
          DO i=istr,iendr
            uout(i,j)=0.5_r8*(uinp(i-1,j)+uinp(i,j))
#  ifdef MASKING
            uout(i,j)=uout(i,j)*grid(ng)%umask(i,j)
#  endif
#  ifdef WET_DRY
            uout(i,j)=uout(i,j)*grid(ng)%umask_wet(i,j)
#  endif
          END DO
        END DO
        DO j=jstr,jendr
          DO i=istrr,iendr
            vout(i,j)=0.5_r8*(vinp(i,j-1)+vinp(i,j))
#  ifdef MASKING
              vout(i,j)=vout(i,j)*grid(ng)%vmask(i,j)
#  endif
#  ifdef WET_DRY
              vout(i,j)=vout(i,j)*grid(ng)%vmask_wet(i,j)
#  endif
          END DO
        END DO
!
        IF (ewperiodic(ng).or.nsperiodic(ng)) THEN
          CALL exchange_u2d_tile (ng, tile,                             &
     &                            lbi, ubi, lbj, ubj,                   &
     &                            uout)
          CALL exchange_v2d_tile (ng, tile,                             &
     &                            lbi, ubi, lbj, ubj,                   &
     &                            vout)
        END IF
      END IF
# endif
!
!-----------------------------------------------------------------------
!  Distributed-memory tile (halo) exchange.
!-----------------------------------------------------------------------
!
      CALL mp_exchange2d (ng, tile, inlm, 2,                            &
     &                    lbi, ubi, lbj, ubj,                           &
     &                    nghostpoints,                                 &
     &                    ewperiodic(ng), nsperiodic(ng),               &
     &                    uout, vout)
!
      IF (esm_track) THEN
        WRITE (trac,'(a,a,i0)') '<== Exiting  ROMS_Rotate',             &
     &                          ', PET', petrank
        FLUSH (trac)
      END IF
!
      END SUBROUTINE roms_rotate
!
      INTEGER FUNCTION field_index (Fnames, Fvalue) RESULT (Findex)
!
!=======================================================================
!                                                                      !
!  This integer function scans an array structure of type ESM_Field    !
!  containing fields short_name list for specific field value and      !
!  returns its location index in the list.                             !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      character (len=*), intent(in) :: fvalue
 
      TYPE (esm_field), intent(in)  :: fnames(:)
!
!  Local variable declarations.
!
      integer :: mfields
      integer :: i
!
!-----------------------------------------------------------------------
!  Find index of specified field from names list.
!-----------------------------------------------------------------------
!
      mfields=SIZE(fnames, dim=1)
      findex=-1
!
      DO i=1,mfields
        IF (trim(fnames(i)%short_name).eq.trim(fvalue)) THEN
          findex=i
          EXIT
        END IF
      END DO
!
      RETURN
      END FUNCTION field_index
!
      SUBROUTINE report_timestamp (field, CurrTime, localPET, string,   &
     &                             rc)
!
!=======================================================================
!                                                                      !
!  Reports coupling time-stamp.                                        !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(in)  :: localpet
      integer, intent(out) :: rc
!
      character (len=*), intent(in) :: string
!
      TYPE (esmf_field), intent(in) :: field
      TYPE (esmf_time),  intent(in) :: currtime
!
!  Local variable declarations.
!
      logical :: isvalid
      integer :: vtime1(10), vtime2(10)
!
      TYPE (esmf_time) :: fieldtime
!
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", report_timestamp"
 
      character (len=22) :: str1, str2
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  Get driver current time.
!-----------------------------------------------------------------------
!
      CALL esmf_timeget (currtime,                                      &
     &                   yy=vtime1(1),                                  &
     &                   mm=vtime1(2),                                  &
     &                   dd=vtime1(3),                                  &
     &                   h =vtime1(4),                                  &
     &                   m =vtime1(5),                                  &
     &                   s =vtime1(6),                                  &
     &                   rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      WRITE (str1,10) vtime1(1), vtime1(2), vtime1(3),                  &
     &                vtime1(4), vtime1(5), vtime1(6)
!
!-----------------------------------------------------------------------
!  Get field TimeStamp.
!-----------------------------------------------------------------------
!
      CALL nuopc_gettimestamp (field,                                   &
     &                         isvalid = isvalid,                       &
     &                         time = fieldtime,                        &
     &                         rc = rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      IF (isvalid) THEN
        CALL esmf_timeget (fieldtime,                                   &
     &                     yy=vtime2(1),                                &
     &                     mm=vtime2(2),                                &
     &                     dd=vtime2(3),                                &
     &                     h =vtime2(4),                                &
     &                     m =vtime2(5),                                &
     &                     s =vtime2(6),                                &
     &                     rc=rc)
        IF (esmf_logfounderror(rctocheck=rc,                            &
     &                         msg=esmf_logerr_passthru,                &
     &                         line=__line__,                           &
     &                         file=myfile)) THEN
          RETURN
        END IF
!
        WRITE (str2,10) vtime2(1), vtime2(2), vtime2(3),                &
     &                  vtime2(4), vtime2(5), vtime2(6)
      END IF
!
!-----------------------------------------------------------------------
!  Report TimeStamp.
!-----------------------------------------------------------------------
!
      IF (isvalid) THEN
        IF (trim(str1).ne.trim(str2)) THEN
          IF (localpet.eq.0) THEN
            WRITE (cplout,20) trim(string), ': TimeStamp = ',           &
     &                        trim(str2), ' not equal ' ,               &
     &                        trim(str1)
          END IF
          rc=esmf_rc_val_wrong
          RETURN
        ELSE
          IF (localpet.eq.0) THEN
!!          WRITE (cplout,30) TRIM(string), ': TimeStamp = ', TRIM(str2)
          END IF
        END IF
      ELSE
        IF (localpet.eq.0) THEN
          WRITE (cplout,30) trim(string), ': TimeStamp is not valid',   &
     &                      ', DriverTime = '//trim(str1)
        END IF
      END IF
!
  10  FORMAT (i4.4,2('-',i2.2),1x,i2.2,':',i2.2,':',i2.2)
  20  FORMAT (/,1x,a,a,a,a,a)
  30  FORMAT (1x,a,a,a)
!
      RETURN
      END SUBROUTINE report_timestamp
!
      SUBROUTINE createscalarfield (Field, Fname, Fcount, rc)
!
!=======================================================================
!                                                                      !
!  Creeates ESMF field to store set scalars                            !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(in)  :: fcount
      integer, intent(out) :: rc
!
      character (len=*), intent(in) :: fname
!
      TYPE (esmf_field) , intent(inout) :: field
!
!  Local variable declarations.
!
      TYPE (esmf_grid)     :: grid
      TYPE (esmf_distgrid) :: distgrid
!
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", CreateScalarField"
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  Create ESMF field
!-----------------------------------------------------------------------
!
      distgrid = esmf_distgridcreate(minindex=(/1/),                    &
     &                               maxindex=(/1/),                    &
     &                               rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      grid = esmf_gridcreate(distgrid, rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      field = esmf_fieldcreate(name=trim(fname),                        &
     &                         grid=grid,                               &
     &                         typekind=esmf_typekind_r8,               &
     &                         gridtofieldmap=(/2/),                    &
     &                         ungriddedlbound=(/1/),                   &
     &                         ungriddedubound=(/fcount/),              &
     &                         rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      RETURN
      END SUBROUTINE createscalarfield
!
      SUBROUTINE setscalarfieldvalues (field, vals, idxs, rc)
!
!=======================================================================
!                                                                      !
!  Sets scalar field.                                                  !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer, intent(in)    :: vals(:)
      integer, intent(in)    :: idxs(:)
      integer, intent(inout) :: rc
!
      TYPE (esmf_field), intent(inout) :: field
!
!  Local variable declarations.
!
      integer                     :: i
      integer                     :: ungriddedlbound(2)
      integer                     :: ungriddedubound(2)
!
      real (r8), pointer          :: fptr(:,:)
!
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", SetScalarFieldValues"
!
!-----------------------------------------------------------------------
!  Initialize return code flag to success state (no error).
!-----------------------------------------------------------------------
!
      rc=esmf_success
!
!-----------------------------------------------------------------------
!  Get pointer and fill the field.
!-----------------------------------------------------------------------
!
      CALL esmf_fieldget(field,                                         &
     &                   ungriddedlbound=ungriddedlbound,               &
     &                   ungriddedubound=ungriddedubound,               &
     &                   rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      IF (any(idxs(:).lt.ungriddedlbound(1)) .or.                       &
          any(idxs(:).gt.ungriddedubound(1))) THEN
        CALL esmf_logseterror(esmf_rc_arg_bad,                          &
     &    msg="ScalarFieldIdxGrid[NX|NY] outside ScalarFieldCount",     &
     &    line=__line__, file=__file__, rctoreturn=rc)
      END IF
!
      CALL esmf_fieldget(field, farrayptr=fptr, rc=rc)
      IF (esmf_logfounderror(rctocheck=rc,                              &
     &                       msg=esmf_logerr_passthru,                  &
     &                       line=__line__,                             &
     &                       file=myfile)) THEN
        RETURN
      END IF
!
      DO i=lbound(idxs, dim=1), ubound(idxs, dim=1)
        fptr(idxs(i),1) = dble(vals(i))
      END DO
!
      RETURN
      END SUBROUTINE setscalarfieldvalues
!
#endif
      END MODULE cmeps_roms_mod