13 use fv_mp_adm_mod, 
only: mpp_update_domains_adm
 
   14 use mpp_domains_mod, 
only: mpp_update_domains, dgrid_ne
 
   15 use mpp_domains_mod, 
only: mpp_get_boundary, mpp_get_boundary_ad
 
   16 use mpp_parameter_mod, 
only: cgrid_ne
 
   18 use femps_fv3_mod, 
only: fv3field_to_ufield, ufield_to_fv3field
 
   19 use femps_grid_mod, 
only: fempsgrid
 
   20 use femps_operators_mod, 
only: fempsoprs
 
   21 use femps_solve_mod, 
only: laplace, inverselaplace
 
   53  real(kind=
kind_real), 
intent(in ) ::   usrf(geom%isc:geom%iec,geom%jsc:geom%jec) 
 
   54  real(kind=
kind_real), 
intent(in ) ::   vsrf(geom%isc:geom%iec,geom%jsc:geom%jec) 
 
   55  real(kind=
kind_real), 
intent(in ) ::   f10r(geom%isc:geom%iec,geom%jsc:geom%jec) 
 
   56  real(kind=
kind_real), 
intent(out) :: spd10m(geom%isc:geom%iec,geom%jsc:geom%jec) 
 
   57  real(kind=
kind_real), 
intent(out) :: dir10m(geom%isc:geom%iec,geom%jsc:geom%jec) 
 
   60  integer :: isc,iec,jsc,jec,i,j
 
   62  real(kind=
kind_real) :: windangle, windratio
 
   63  real(kind=
kind_real), 
parameter :: windscale = 999999.0_kind_real
 
   64  real(kind=
kind_real), 
parameter :: windlimit = 0.0001_kind_real
 
   65  real(kind=
kind_real), 
parameter :: quadcof(4,2) = reshape((/ 0.0_kind_real,  1.0_kind_real, &
 
   66                                                               1.0_kind_real,  2.0_kind_real, &
 
   67                                                               1.0_kind_real, -1.0_kind_real, &
 
   68                                                               1.0_kind_real, -1.0_kind_real /), (/4, 2/))
 
   78  spd10m(isc:iec,jsc:jec) = f10r(isc:iec,jsc:jec)*sqrt( usrf(isc:iec,jsc:jec)*usrf(isc:iec,jsc:jec) + &
 
   79                                                       vsrf(isc:iec,jsc:jec)*vsrf(isc:iec,jsc:jec) )
 
   85      if (usrf(i,j)*f10r(i,j) >= 0.0_kind_real .and. vsrf(i,j)*f10r(i,j) >= 0.0_kind_real) iquad = 1
 
   86      if (usrf(i,j)*f10r(i,j) >= 0.0_kind_real .and. vsrf(i,j)*f10r(i,j) <  0.0_kind_real) iquad = 2
 
   87      if (usrf(i,j)*f10r(i,j) <  0.0_kind_real .and. vsrf(i,j)*f10r(i,j) >= 0.0_kind_real) iquad = 3
 
   88      if (usrf(i,j)*f10r(i,j) <  0.0_kind_real .and. vsrf(i,j)*f10r(i,j) <  0.0_kind_real) iquad = 4
 
   90      if (abs(vsrf(i,j)*f10r(i,j)) >= windlimit) 
then 
   91         windratio = (usrf(i,j)*f10r(i,j)) / (vsrf(i,j)*f10r(i,j))
 
   93         windratio = 0.0_kind_real
 
   94         if (abs(usrf(i,j)*f10r(i,j)) > windlimit) 
then 
   95           windratio = windscale * usrf(i,j)*f10r(i,j)
 
   99      windangle = atan(abs(windratio))
 
  101      dir10m(i,j) = 
rad2deg*(quadcof(iquad,1) * 
pi + windangle * quadcof(iquad, 2))
 
  114  real(kind=
kind_real), 
intent(inout) :: psi(geom%isd:geom%ied,geom%jsd:geom%jed,1:geom%npz) 
 
  115  real(kind=
kind_real), 
intent(inout) :: chi(geom%isd:geom%ied,geom%jsd:geom%jed,1:geom%npz) 
 
  116  real(kind=
kind_real), 
intent(out)   ::  ua(geom%isc:geom%iec,geom%jsc:geom%jec,1:geom%npz) 
 
  117  real(kind=
kind_real), 
intent(out)   ::  va(geom%isc:geom%iec,geom%jsc:geom%jec,1:geom%npz) 
 
  132  call mpp_update_domains(psi, geom%domain, complete=.true.)
 
  133  call mpp_update_domains(chi, geom%domain, complete=.true.)
 
  136    do j=geom%jsc,geom%jec
 
  137      do i=geom%isc,geom%iec
 
  139         ua(i,j,k) =  (psi(i,j+1,k) - psi(i,j-1,k))/(geom%dyc(i,j) + geom%dyc(i,j+1)) + &
 
  140                      (chi(i+1,j,k) - chi(i-1,j,k))/(geom%dxc(i,j) + geom%dxc(i+1,j))
 
  141         va(i,j,k) = -(psi(i+1,j,k) - psi(i-1,j,k))/(geom%dxc(i,j) + geom%dxc(i+1,j)) + &
 
  142                      (chi(i,j+1,k) - chi(i,j-1,k))/(geom%dyc(i,j) + geom%dyc(i,j+1))
 
  156  real(kind=
kind_real), 
intent(in)    :: psi(geom%isc:geom%iec  ,geom%jsc:geom%jec  ,1:geom%npz) 
 
  157  real(kind=
kind_real), 
intent(in)    :: chi(geom%isc:geom%iec  ,geom%jsc:geom%jec  ,1:geom%npz) 
 
  158  real(kind=
kind_real), 
intent(out)   ::   u(geom%isc:geom%iec  ,geom%jsc:geom%jec+1,1:geom%npz) 
 
  159  real(kind=
kind_real), 
intent(out)   ::   v(geom%isc:geom%iec+1,geom%jsc:geom%jec  ,1:geom%npz) 
 
  162  real(kind=
kind_real), 
allocatable, 
dimension(:,:,:) :: psid, chid
 
  163  real(kind=
kind_real) :: u_rot(geom%isd:geom%ied  ,geom%jsd:geom%jed+1,1:geom%npz) 
 
  164  real(kind=
kind_real) :: v_rot(geom%isd:geom%ied+1,geom%jsd:geom%jed  ,1:geom%npz) 
 
  165  real(kind=
kind_real) :: u_div(geom%isd:geom%ied  ,geom%jsd:geom%jed+1,1:geom%npz) 
 
  166  real(kind=
kind_real) :: v_div(geom%isd:geom%ied+1,geom%jsd:geom%jed  ,1:geom%npz) 
 
  168  real(kind=
kind_real) :: uc_div(geom%isd:geom%ied+1,geom%jsd:geom%jed  ,1:geom%npz) 
 
  169  real(kind=
kind_real) :: vc_div(geom%isd:geom%ied  ,geom%jsd:geom%jed+1,1:geom%npz) 
 
  170  real(kind=
kind_real) :: ua_div(geom%isd:geom%ied  ,geom%jsd:geom%jed  ,1:geom%npz) 
 
  171  real(kind=
kind_real) :: va_div(geom%isd:geom%ied  ,geom%jsd:geom%jed  ,1:geom%npz) 
 
  175  allocate(psid(geom%isd:geom%ied,geom%jsd:geom%jed,1:geom%npz))
 
  176  allocate(chid(geom%isd:geom%ied,geom%jsd:geom%jed,1:geom%npz))
 
  180  psid(geom%isc:geom%iec,geom%jsc:geom%jec,:) = psi(geom%isc:geom%iec,geom%jsc:geom%jec,:)
 
  181  chid(geom%isc:geom%iec,geom%jsc:geom%jec,:) = chi(geom%isc:geom%iec,geom%jsc:geom%jec,:)
 
  183  call mpp_update_domains(psid, geom%domain, complete=.true.)
 
  184  call mpp_update_domains(chid, geom%domain, complete=.true.)
 
  191    do j=geom%jsc,geom%jec+1
 
  192      do i=geom%isc,geom%iec
 
  193         u_rot(i,j,k) = -(psid(i,j,k) - psid(i,j-1,k))/geom%dyc(i,j)
 
  199    do j=geom%jsc,geom%jec
 
  200      do i=geom%isc,geom%iec+1
 
  201         v_rot(i,j,k) = (psid(i,j,k) - psid(i-1,j,k))/geom%dxc(i,j)
 
  207    do j=geom%jsc,geom%jec
 
  208      do i=geom%isc,geom%iec+1
 
  209         uc_div(i,j,k) = (chid(i,j,k) - chid(i-1,j,k))/geom%dxc(i,j)
 
  215    do j=geom%jsc,geom%jec+1
 
  216      do i=geom%isc,geom%iec
 
  217         vc_div(i,j,k) = (chid(i,j,k) - chid(i,j-1,k))/geom%dyc(i,j)
 
  227    call ctoa(geom, uc_div(:,:,k), vc_div(:,:,k), ua_div(:,:,k), va_div(:,:,k))
 
  234    call atod(geom, ua_div(:,:,k), va_div(:,:,k), u_div(:,:,k), v_div(:,:,k))
 
  244    do j=geom%jsc,geom%jec+1
 
  245      do i=geom%isc,geom%iec
 
  246         u(i,j,k) = u_rot(i,j,k) + u_div(i,j,k)
 
  252    do j=geom%jsc,geom%jec
 
  253      do i=geom%isc,geom%iec+1
 
  254         v(i,j,k) = v_rot(i,j,k) + v_div(i,j,k)
 
  267  real(kind=
kind_real), 
intent(inout) :: psi_ad(geom%isd:geom%ied,geom%jsd:geom%jed,1:geom%npz) 
 
  268  real(kind=
kind_real), 
intent(inout) :: chi_ad(geom%isd:geom%ied,geom%jsd:geom%jed,1:geom%npz) 
 
  269  real(kind=
kind_real), 
intent(inout)   ::  ua_ad(geom%isc:geom%iec,geom%jsc:geom%jec,1:geom%npz) 
 
  270  real(kind=
kind_real), 
intent(inout)   ::  va_ad(geom%isc:geom%iec,geom%jsc:geom%jec,1:geom%npz) 
 
  290    do j=geom%jec,geom%jsc,-1
 
  291      do i=geom%iec,geom%isc,-1
 
  293        temp1 =   va_ad(i,j,k)/(geom%dyc(i,j)+geom%dyc(i,j+1))
 
  294        temp2 = -(va_ad(i,j,k)/(geom%dxc(i,j)+geom%dxc(i+1,j)))
 
  295        chi_ad(i,j+1,k) = chi_ad(i,j+1,k) + temp1
 
  296        chi_ad(i,j-1,k) = chi_ad(i,j-1,k) - temp1
 
  297        psi_ad(i+1,j,k) = psi_ad(i+1,j,k) + temp2
 
  298        psi_ad(i-1,j,k) = psi_ad(i-1,j,k) - temp2
 
  301        temp3 = ua_ad(i,j,k)/(geom%dyc(i,j)+geom%dyc(i,j+1))
 
  302        temp4 = ua_ad(i,j,k)/(geom%dxc(i,j)+geom%dxc(i+1,j))
 
  303        psi_ad(i,j+1,k) = psi_ad(i,j+1,k) + temp3
 
  304        psi_ad(i,j-1,k) = psi_ad(i,j-1,k) - temp3
 
  305        chi_ad(i+1,j,k) = chi_ad(i+1,j,k) + temp4
 
  306        chi_ad(i-1,j,k) = chi_ad(i-1,j,k) - temp4
 
  313  call mpp_update_domains_adm(ua_ad, chi_ad, geom%domain, complete=.true.)
 
  314  call mpp_update_domains_adm(va_ad, psi_ad, geom%domain, complete=.true.)
 
  320 subroutine udvd_to_psichi(geom,grid,oprs,u_in,v_in,psi,chi,lsize,lev_start,lev_final,vor_out,div_out)
 
  324  type(fempsgrid),                
intent(in)    :: grid
 
  325  type(fempsoprs),                
intent(in)    :: oprs
 
  326  real(kind=
kind_real),           
intent(inout) :: u_in(geom%isc:geom%iec  ,geom%jsc:geom%jec+1,1:geom%npz) 
 
  327  real(kind=
kind_real),           
intent(inout) :: v_in(geom%isc:geom%iec+1,geom%jsc:geom%jec  ,1:geom%npz) 
 
  328  real(kind=
kind_real),           
intent(out)   ::  psi(geom%isc:geom%iec  ,geom%jsc:geom%jec  ,1:geom%npz) 
 
  329  real(kind=
kind_real),           
intent(out)   ::  chi(geom%isc:geom%iec  ,geom%jsc:geom%jec  ,1:geom%npz) 
 
  330  integer,                        
intent(in)    :: lsize
 
  331  integer,                        
intent(in)    :: lev_start(lsize),lev_final(lsize)
 
  332  real(kind=
kind_real), 
optional, 
intent(out)   :: vor_out(geom%isc:geom%iec,geom%jsc:geom%jec,1:geom%npz) 
 
  333  real(kind=
kind_real), 
optional, 
intent(out)   :: div_out(geom%isc:geom%iec,geom%jsc:geom%jec,1:geom%npz) 
 
  336  real(kind=
kind_real), 
allocatable, 
dimension(:,:,:) :: u, v
 
  337  real(kind=
kind_real), 
allocatable, 
dimension(:,:,:) :: uc, vc
 
  338  real(kind=
kind_real), 
allocatable, 
dimension(:,:,:) :: ut, vt
 
  340  real(kind=
kind_real), 
allocatable, 
dimension(:,:,:) :: vor, div
 
  342  real(kind=
kind_real), 
allocatable, 
dimension(:,:,:) :: vorgcomm, divgcomm
 
  343  real(kind=
kind_real), 
allocatable, 
dimension(:,:,:) :: psigcomm, chigcomm
 
  344  real(kind=
kind_real), 
allocatable, 
dimension(:,:,:,:) :: vorg, divg 
 
  345  real(kind=
kind_real), 
allocatable, 
dimension(:,:,:,:) :: psig, chig 
 
  347  real(kind=
kind_real), 
allocatable, 
dimension(:) :: voru, divu     
 
  348  real(kind=
kind_real), 
allocatable, 
dimension(:) :: psiu, chiu     
 
  351  integer, 
allocatable :: lev_proc(:)
 
  360  allocate(u(geom%isd:geom%ied  ,geom%jsd:geom%jed+1,1:geom%npz))
 
  361  allocate(v(geom%isd:geom%ied+1,geom%jsd:geom%jed  ,1:geom%npz))
 
  364  u(geom%isc:geom%iec,geom%jsc:geom%jec,1:geom%npz) = u_in(geom%isc:geom%iec,geom%jsc:geom%jec,1:geom%npz)
 
  365  v(geom%isc:geom%iec,geom%jsc:geom%jec,1:geom%npz) = v_in(geom%isc:geom%iec,geom%jsc:geom%jec,1:geom%npz)
 
  372  allocate(uc(geom%isd:geom%ied+1,geom%jsd:geom%jed  ,1:geom%npz))
 
  373  allocate(vc(geom%isd:geom%ied  ,geom%jsd:geom%jed+1,1:geom%npz))
 
  376    call udvd_to_ucvc(geom,u(:,:,k),v(:,:,k),uc(:,:,k),vc(:,:,k))
 
  384  allocate(ut(geom%isd:geom%ied+1,geom%jsd:geom%jed  ,1:geom%npz))
 
  385  allocate(vt(geom%isd:geom%ied  ,geom%jsd:geom%jed+1,1:geom%npz))
 
  389    call compute_utvt(geom, uc(:,:,k), vc(:,:,k), ut(:,:,k), vt(:,:,k), 1.0_kind_real)
 
  391    do j=geom%jsc,geom%jec
 
  392       do i=geom%isc,geom%iec+1
 
  393          if ( ut(i,j,k) > 0. ) 
then 
  394               ut(i,j,k) = geom%dy(i,j)*ut(i,j,k)*geom%sin_sg(i-1,j,3)
 
  396               ut(i,j,k) = geom%dy(i,j)*ut(i,j,k)*geom%sin_sg(i,j,1)
 
  400    do j=geom%jsc,geom%jec+1
 
  401       do i=geom%isc,geom%iec
 
  402          if ( vt(i,j,k) > 0. ) 
then 
  403               vt(i,j,k) = geom%dx(i,j)*vt(i,j,k)*geom%sin_sg(i,j-1,4)
 
  405               vt(i,j,k) = geom%dx(i,j)*vt(i,j,k)*geom%sin_sg(i,j,2)
 
  414  allocate(vor(geom%isc:geom%iec,geom%jsc:geom%jec,1:geom%npz))
 
  415  allocate(div(geom%isc:geom%iec,geom%jsc:geom%jec,1:geom%npz))
 
  420    do j=geom%jsc,geom%jec
 
  421      do i=geom%isc,geom%iec
 
  422        vor(i,j,k) = geom%rarea(i,j)*( u(i,j,k)*geom%dx(i,j)-u(i,j+1,k)*geom%dx(i,j+1) - &
 
  423                                       v(i,j,k)*geom%dy(i,j)+v(i+1,j,k)*geom%dy(i+1,j))
 
  424        div(i,j,k) = geom%rarea(i,j)*( ut(i+1,j,k)-ut(i,j,k) + vt(i,j+1,k)-vt(i,j,k) )
 
  431  if (
present(vor_out)) vor_out = vor
 
  432  if (
present(div_out)) div_out = div
 
  437  ranki = geom%f_comm%rank() + 1
 
  439  allocate(vorgcomm(1:geom%npx-1,1:geom%npy-1,6))
 
  440  allocate(divgcomm(1:geom%npx-1,1:geom%npy-1,6))
 
  442  if (ranki <= lsize) 
then 
  443    allocate(vorg(1:geom%npx-1,1:geom%npy-1,6,lev_start(ranki):lev_final(ranki)))
 
  444    allocate(divg(1:geom%npx-1,1:geom%npy-1,6,lev_start(ranki):lev_final(ranki)))
 
  445    allocate(psig(1:geom%npx-1,1:geom%npy-1,6,lev_start(ranki):lev_final(ranki)))
 
  446    allocate(chig(1:geom%npx-1,1:geom%npy-1,6,lev_start(ranki):lev_final(ranki)))
 
  448    allocate(voru(grid%nface(grid%ngrids)))
 
  449    allocate(divu(grid%nface(grid%ngrids)))
 
  450    allocate(psiu(grid%nface(grid%ngrids)))
 
  451    allocate(chiu(grid%nface(grid%ngrids)))
 
  455  allocate(lev_proc(geom%npz))
 
  458      if (k >= lev_start(n) .and. k <= lev_final(n)) 
then 
  466    call gather_field(geom,geom%f_comm%communicator(),lev_proc(k)-1,vor(:,:,k),vorgcomm)
 
  467    call gather_field(geom,geom%f_comm%communicator(),lev_proc(k)-1,div(:,:,k),divgcomm)
 
  468    if (ranki == lev_proc(k)) 
then 
  469      vorg(:,:,:,k) = vorgcomm
 
  470      divg(:,:,:,k) = divgcomm
 
  474  deallocate(vorgcomm,divgcomm)
 
  477  if (ranki <= lsize) 
then  
  478    do k = lev_start(ranki),lev_final(ranki)
 
  480      if (geom%f_comm%rank()==0) &
 
  481        print*, 
"Doing femps level ", k, 
". Proc range:",lev_start(ranki),
"-",lev_final(ranki)
 
  483      call fv3field_to_ufield(grid,geom%npx-1,vorg(:,:,:,k),voru)
 
  484      call fv3field_to_ufield(grid,geom%npx-1,divg(:,:,:,k),divu)
 
  487      voru = voru*grid%farea(:,grid%ngrids)
 
  488      divu = divu*grid%farea(:,grid%ngrids)
 
  491      call inverselaplace(grid,oprs,grid%ngrids,voru,psiu,level=k)
 
  492      call inverselaplace(grid,oprs,grid%ngrids,divu,chiu,level=k)
 
  495      psiu = psiu/grid%farea(:,grid%ngrids)
 
  496      chiu = chiu/grid%farea(:,grid%ngrids)
 
  498      call ufield_to_fv3field(grid,geom%npx-1,psiu,psig(:,:,:,k))
 
  499      call ufield_to_fv3field(grid,geom%npx-1,chiu,chig(:,:,:,k))
 
  505  allocate(psigcomm(1:geom%npx-1,1:geom%npy-1,6))
 
  506  allocate(chigcomm(1:geom%npx-1,1:geom%npy-1,6))
 
  509    if (ranki == lev_proc(k)) 
then 
  510      psigcomm = psig(:,:,:,k)
 
  511      chigcomm = chig(:,:,:,k)
 
  513    call scatter_field(geom,geom%f_comm%communicator(),lev_proc(k)-1,psigcomm,psi(:,:,k))
 
  514    call scatter_field(geom,geom%f_comm%communicator(),lev_proc(k)-1,chigcomm,chi(:,:,k))
 
  525  type(fempsgrid),                
intent(in)    :: grid
 
  526  type(fempsoprs),                
intent(in)    :: oprs
 
  527  real(kind=
kind_real),           
intent(in)    ::  psi(geom%isc:geom%iec,geom%jsc:geom%jec,1:geom%npz) 
 
  528  real(kind=
kind_real),           
intent(in)    ::  chi(geom%isc:geom%iec,geom%jsc:geom%jec,1:geom%npz) 
 
  529  integer,                        
intent(in)    :: lsize
 
  530  integer,                        
intent(in)    :: lev_start(lsize),lev_final(lsize)
 
  531  real(kind=
kind_real), 
optional, 
intent(out)   ::  vor(geom%isc:geom%iec,geom%jsc:geom%jec,1:geom%npz) 
 
  532  real(kind=
kind_real), 
optional, 
intent(out)   ::  div(geom%isc:geom%iec,geom%jsc:geom%jec,1:geom%npz) 
 
  535  real(kind=
kind_real), 
allocatable, 
dimension(:,:,:) :: vorgcomm, divgcomm
 
  536  real(kind=
kind_real), 
allocatable, 
dimension(:,:,:) :: psigcomm, chigcomm
 
  537  real(kind=
kind_real), 
allocatable, 
dimension(:,:,:,:) :: vorg, divg 
 
  538  real(kind=
kind_real), 
allocatable, 
dimension(:,:,:,:) :: psig, chig 
 
  539  real(kind=
kind_real), 
allocatable, 
dimension(:) :: voru, divu     
 
  540  real(kind=
kind_real), 
allocatable, 
dimension(:) :: psiu, chiu     
 
  543  integer, 
allocatable :: lev_proc(:)
 
  548  ranki = geom%f_comm%rank() + 1
 
  550   if (ranki <= lsize) 
then 
  551     allocate(vorg(1:geom%npx-1,1:geom%npy-1,6,lev_start(ranki):lev_final(ranki)))
 
  552     allocate(divg(1:geom%npx-1,1:geom%npy-1,6,lev_start(ranki):lev_final(ranki)))
 
  553     allocate(psig(1:geom%npx-1,1:geom%npy-1,6,lev_start(ranki):lev_final(ranki)))
 
  554     allocate(chig(1:geom%npx-1,1:geom%npy-1,6,lev_start(ranki):lev_final(ranki)))
 
  555     allocate(voru(grid%nface(grid%ngrids)))
 
  556     allocate(divu(grid%nface(grid%ngrids)))
 
  557     allocate(psiu(grid%nface(grid%ngrids)))
 
  558     allocate(chiu(grid%nface(grid%ngrids)))
 
  562  allocate(lev_proc(geom%npz))
 
  565      if (k >= lev_start(n) .and. k <= lev_final(n)) 
then 
  571  allocate(psigcomm(1:geom%npx-1,1:geom%npy-1,6))
 
  572  allocate(chigcomm(1:geom%npx-1,1:geom%npy-1,6))
 
  574    call gather_field(geom,geom%f_comm%communicator(),lev_proc(k)-1,psi(:,:,k),psigcomm)
 
  575    call gather_field(geom,geom%f_comm%communicator(),lev_proc(k)-1,chi(:,:,k),chigcomm)
 
  576    if (ranki == lev_proc(k)) 
then 
  577      psig(:,:,:,k) = psigcomm
 
  578      chig(:,:,:,k) = chigcomm
 
  581  deallocate(psigcomm,chigcomm)
 
  584  if (ranki <= lsize) 
then  
  585    do k = lev_start(ranki),lev_final(ranki)
 
  587      if (geom%f_comm%rank()==0) &
 
  588        print*, 
"Doing femps level ", k, 
". Proc range:",lev_start(ranki),
"-",lev_final(ranki)
 
  590      call fv3field_to_ufield(grid,geom%npx-1,psig(:,:,:,k),psiu)
 
  591      call fv3field_to_ufield(grid,geom%npx-1,chig(:,:,:,k),chiu)
 
  594      psiu = psiu*grid%farea(:,grid%ngrids)
 
  595      chiu = chiu*grid%farea(:,grid%ngrids)
 
  598      call laplace(grid,oprs,grid%ngrids,psiu,voru)
 
  599      call laplace(grid,oprs,grid%ngrids,chiu,divu)
 
  602      voru = voru/grid%farea(:,grid%ngrids)
 
  603      divu = divu/grid%farea(:,grid%ngrids)
 
  605      call ufield_to_fv3field(grid,geom%npx-1,voru,vorg(:,:,:,k))
 
  606      call ufield_to_fv3field(grid,geom%npx-1,divu,divg(:,:,:,k))
 
  612  allocate(vorgcomm(1:geom%npx-1,1:geom%npy-1,6))
 
  613  allocate(divgcomm(1:geom%npx-1,1:geom%npy-1,6))
 
  615    if (ranki == lev_proc(k)) 
then 
  616      vorgcomm = vorg(:,:,:,k)
 
  617      divgcomm = divg(:,:,:,k)
 
  619    call scatter_field(geom,geom%f_comm%communicator(),lev_proc(k)-1,vorgcomm,vor(:,:,k))
 
  620    call scatter_field(geom,geom%f_comm%communicator(),lev_proc(k)-1,divgcomm,div(:,:,k))
 
  622  deallocate(vorgcomm,divgcomm)
 
  632 real(kind=
kind_real),           
intent(in)    ::  u(geom%isd:geom%ied  ,geom%jsd:geom%jed+1) 
 
  633 real(kind=
kind_real),           
intent(in)    ::  v(geom%isd:geom%ied+1,geom%jsd:geom%jed  ) 
 
  634 real(kind=
kind_real),           
intent(out)   :: uc(geom%isd:geom%ied+1,geom%jsd:geom%jed  ) 
 
  635 real(kind=
kind_real),           
intent(out)   :: vc(geom%isd:geom%ied  ,geom%jsd:geom%jed+1) 
 
  636 real(kind=
kind_real), 
optional, 
intent(out)   :: ua_out(geom%isd:geom%ied  ,geom%jsd:geom%jed) 
 
  637 real(kind=
kind_real), 
optional, 
intent(out)   :: va_out(geom%isd:geom%ied  ,geom%jsd:geom%jed) 
 
  640 real(kind=
kind_real) :: ut(geom%isd:geom%ied  ,geom%jsd:geom%jed  )
 
  641 real(kind=
kind_real) :: vt(geom%isd:geom%ied  ,geom%jsd:geom%jed  )
 
  642 real(kind=
kind_real) :: utmp(geom%isd:geom%ied  ,geom%jsd:geom%jed  )
 
  643 real(kind=
kind_real) :: vtmp(geom%isd:geom%ied  ,geom%jsd:geom%jed  )
 
  644 real(kind=
kind_real) :: ua(geom%isd:geom%ied  ,geom%jsd:geom%jed )
 
  645 real(kind=
kind_real) :: va(geom%isd:geom%ied  ,geom%jsd:geom%jed )
 
  652 real(kind=
kind_real), 
parameter:: a1 =  0.5625_kind_real
 
  653 real(kind=
kind_real), 
parameter:: a2 = -0.0625_kind_real
 
  654 real(kind=
kind_real), 
parameter:: c1 = -2.0_kind_real/14.0_kind_real
 
  655 real(kind=
kind_real), 
parameter:: c2 = 11.0_kind_real/14.0_kind_real
 
  656 real(kind=
kind_real), 
parameter:: c3 =  5.0_kind_real/14.0_kind_real
 
  658 integer npt, i, j, ifirst, ilast, id
 
  659 integer :: is,  ie,  js,  je
 
  660 integer :: isd, ied, jsd, jed
 
  661 real(kind=
kind_real), 
pointer, 
dimension(:,:,:) :: sin_sg
 
  662 real(kind=
kind_real), 
pointer, 
dimension(:,:)   :: cosa_u, cosa_v, cosa_s
 
  663 real(kind=
kind_real), 
pointer, 
dimension(:,:)   :: rsin_u, rsin_v, rsin2
 
  664 real(kind=
kind_real), 
pointer, 
dimension(:,:)   :: dxa,dya
 
  679 grid_type = geom%grid_type
 
  681 sin_sg    => geom%sin_sg
 
  682 cosa_u    => geom%cosa_u
 
  683 cosa_v    => geom%cosa_v
 
  684 cosa_s    => geom%cosa_s
 
  685 rsin_u    => geom%rsin_u
 
  686 rsin_v    => geom%rsin_v
 
  691 if ( geom%dord4 ) 
then 
  697 if (grid_type < 3 .and. .not. nested) 
then 
  704 utmp(:,:) = 1.0e30_kind_real
 
  705 vtmp(:,:) = 1.0e30_kind_real
 
  711       utmp(i,j) = a2*(u(i,j-1)+u(i,j+2)) + a1*(u(i,j)+u(i,j+1))
 
  717     utmp(i,j) = 0.5*(u(i,j)+u(i,j+1))
 
  719     utmp(i,j) = 0.5*(u(i,j)+u(i,j+1))
 
  724       vtmp(i,j) = a2*(v(i-1,j)+v(i+2,j)) + a1*(v(i,j)+v(i+1,j))
 
  727     vtmp(i,j) = 0.5*(v(i,j)+v(i+1,j))
 
  729     vtmp(i,j) = 0.5*(v(i,j)+v(i+1,j))
 
  734       ua(i,j) = (utmp(i,j)-vtmp(i,j)*cosa_s(i,j)) * rsin2(i,j)
 
  735       va(i,j) = (vtmp(i,j)-utmp(i,j)*cosa_s(i,j)) * rsin2(i,j)
 
  744   do j=max(npt,js-1),min(npy-npt,je+1)
 
  745     do i=max(npt,isd),min(npx-npt,ied)
 
  746       utmp(i,j) = a2*(u(i,j-1)+u(i,j+2)) + a1*(u(i,j)+u(i,j+1))
 
  749   do j=max(npt,jsd),min(npy-npt,jed)
 
  750     do i=max(npt,is-1),min(npx-npt,ie+1)
 
  751       vtmp(i,j) = a2*(v(i-1,j)+v(i+2,j)) + a1*(v(i,j)+v(i+1,j))
 
  758   if (grid_type < 3) 
then 
  760     if ( js==1 .or. jsd<npt) 
then 
  763           utmp(i,j) = 0.5*(u(i,j) + u(i,j+1))
 
  764           vtmp(i,j) = 0.5*(v(i,j) + v(i+1,j))
 
  769     if ( (je+1)==npy .or. jed>=(npy-npt)) 
then 
  772           utmp(i,j) = 0.5*(u(i,j) + u(i,j+1))
 
  773           vtmp(i,j) = 0.5*(v(i,j) + v(i+1,j))
 
  778     if ( is==1 .or. isd<npt ) 
then 
  779       do j=max(npt,jsd),min(npy-npt,jed)
 
  781           utmp(i,j) = 0.5*(u(i,j) + u(i,j+1))
 
  782           vtmp(i,j) = 0.5*(v(i,j) + v(i+1,j))
 
  786     if ( (ie+1)==npx .or. ied>=(npx-npt)) 
then 
  787       do j=max(npt,jsd),min(npy-npt,jed)
 
  789           utmp(i,j) = 0.5*(u(i,j) + u(i,j+1))
 
  790           vtmp(i,j) = 0.5*(v(i,j) + v(i+1,j))
 
  800       ua(i,j) = (utmp(i,j)-vtmp(i,j)*cosa_s(i,j)) * rsin2(i,j)
 
  801       va(i,j) = (vtmp(i,j)-utmp(i,j)*cosa_s(i,j)) * rsin2(i,j)
 
  812 if( geom%sw_corner ) 
then 
  814     utmp(i,0) = -vtmp(0,1-i)
 
  817 if( geom%se_corner ) 
then 
  819     utmp(npx+i,0) = vtmp(npx,i+1)
 
  822 if( geom%ne_corner ) 
then 
  824     utmp(npx+i,npy) = -vtmp(npx,je-i)
 
  827 if( geom%nw_corner ) 
then 
  829     utmp(i,npy) = vtmp(0,je+i)
 
  833 if (grid_type < 3 .and. .not. nested) 
then 
  834   ifirst = max(3,    is-1)
 
  835   ilast  = min(npx-2,ie+2)
 
  846     uc(i,j) = a2*(utmp(i-2,j)+utmp(i+1,j)) + a1*(utmp(i-1,j)+utmp(i,j))
 
  847     ut(i,j) = (uc(i,j) - v(i,j)*cosa_u(i,j))*rsin_u(i,j)
 
  851 if (grid_type < 3) 
then 
  853   if( geom%sw_corner ) 
then 
  857   if( geom%se_corner ) 
then 
  858     ua(npx,  0) = va(npx,1)
 
  859     ua(npx+1,0) = va(npx,2)
 
  861   if( geom%ne_corner ) 
then 
  862     ua(npx,  npy) = -va(npx,npy-1)
 
  863     ua(npx+1,npy) = -va(npx,npy-2)
 
  865   if( geom%nw_corner ) 
then 
  866     ua(-1,npy) = va(0,npy-2)
 
  867     ua( 0,npy) = va(0,npy-1)
 
  870   if( is==1 .and. .not. nested  ) 
then 
  872       uc(0,j) = c1*utmp(-2,j) + c2*utmp(-1,j) + c3*utmp(0,j)
 
  875       if (ut(1,j) > 0.) 
then 
  876         uc(1,j) = ut(1,j)*sin_sg(0,j,3)
 
  878         uc(1,j) = ut(1,j)*sin_sg(1,j,1)
 
  880       uc(2,j) = c1*utmp(3,j) + c2*utmp(2,j) + c3*utmp(1,j)
 
  881       ut(0,j) = (uc(0,j) - v(0,j)*cosa_u(0,j))*rsin_u(0,j)
 
  882       ut(2,j) = (uc(2,j) - v(2,j)*cosa_u(2,j))*rsin_u(2,j)
 
  886   if( (ie+1)==npx  .and. .not. nested ) 
then 
  888       uc(npx-1,j) = c1*utmp(npx-3,j)+c2*utmp(npx-2,j)+c3*utmp(npx-1,j)
 
  890       if (ut(npx,j) > 0.) 
then 
  891         uc(npx,j) = ut(npx,j)*sin_sg(npx-1,j,3)
 
  893         uc(npx,j) = ut(npx,j)*sin_sg(npx,j,1)
 
  895       uc(npx+1,j) = c3*utmp(npx,j) + c2*utmp(npx+1,j) + c1*utmp(npx+2,j)
 
  896       ut(npx-1,j) = (uc(npx-1,j)-v(npx-1,j)*cosa_u(npx-1,j))*rsin_u(npx-1,j)
 
  897       ut(npx+1,j) = (uc(npx+1,j)-v(npx+1,j)*cosa_u(npx+1,j))*rsin_u(npx+1,j)
 
  906 if( geom%sw_corner ) 
then 
  908     vtmp(0,j) = -utmp(1-j,0)
 
  911   if( geom%nw_corner ) 
then 
  913       vtmp(0,npy+j) = utmp(j+1,npy)
 
  916   if( geom%se_corner ) 
then 
  918       vtmp(npx,j) = utmp(ie+j,0)
 
  921   if( geom%ne_corner ) 
then 
  923       vtmp(npx,npy+j) = -utmp(ie-j,npy)
 
  926   if( geom%sw_corner ) 
then 
  930   if( geom%se_corner ) 
then 
  931     va(npx, 0) = ua(npx-1,0)
 
  932     va(npx,-1) = ua(npx-2,0)
 
  934   if( geom%ne_corner ) 
then 
  935     va(npx,npy  ) = -ua(npx-1,npy)
 
  936     va(npx,npy+1) = -ua(npx-2,npy)
 
  938   if( geom%nw_corner ) 
then 
  939     va(0,npy)   = ua(1,npy)
 
  940     va(0,npy+1) = ua(2,npy)
 
  943 if (grid_type < 3) 
then 
  946     if ( j==1 .and. .not. nested  ) 
then 
  949         if (vt(i,j) > 0.) 
then 
  950           vc(i,j) = vt(i,j)*sin_sg(i,j-1,4)
 
  952           vc(i,j) = vt(i,j)*sin_sg(i,j,2)
 
  955     elseif ( j==0 .or. j==(npy-1) .and. .not. nested  ) 
then 
  957         vc(i,j) = c1*vtmp(i,j-2) + c2*vtmp(i,j-1) + c3*vtmp(i,j)
 
  958         vt(i,j) = (vc(i,j) - u(i,j)*cosa_v(i,j))*rsin_v(i,j)
 
  960     elseif ( j==2 .or. j==(npy+1)  .and. .not. nested ) 
then 
  962         vc(i,j) = c1*vtmp(i,j+1) + c2*vtmp(i,j) + c3*vtmp(i,j-1)
 
  963         vt(i,j) = (vc(i,j) - u(i,j)*cosa_v(i,j))*rsin_v(i,j)
 
  965     elseif ( j==npy .and. .not. nested  ) 
then 
  968         if (vt(i,j) > 0.) 
then 
  969           vc(i,j) = vt(i,j)*sin_sg(i,j-1,4)
 
  971           vc(i,j) = vt(i,j)*sin_sg(i,j,2)
 
  978         vc(i,j) = a2*(vtmp(i,j-2)+vtmp(i,j+1)) + a1*(vtmp(i,j-1)+vtmp(i,j))
 
  979         vt(i,j) = (vc(i,j) - u(i,j)*cosa_v(i,j))*rsin_v(i,j)
 
  989       vc(i,j) = a2*(vtmp(i,j-2)+vtmp(i,j+1)) + a1*(vtmp(i,j-1)+vtmp(i,j))
 
  996 if (
present(ua_out) .and. 
present(va_out)) 
then 
  997   ua_out(is:ie,js:je) = ua(is:ie,js:je)
 
  998   va_out(is:ie,js:je) = va(is:ie,js:je)
 
 1008 real(kind=
kind_real), 
intent(in) :: ua(4)
 
 1009 real(kind=
kind_real), 
intent(in) :: dxa(4)
 
 1012 t1 = dxa(1) + dxa(2)
 
 1013 t2 = dxa(3) + dxa(4)
 
 1016                           ((t2+dxa(3))*ua(3)-dxa(3)*ua(4)) / t2 )
 
 1022 subroutine a2d(geom, ua, va, ud, vd)
 
 1027 real(kind=
kind_real), 
intent(in)    :: ua(geom%isc:geom%iec,  geom%jsc:geom%jec,  geom%npz)
 
 1028 real(kind=
kind_real), 
intent(in)    :: va(geom%isc:geom%iec,  geom%jsc:geom%jec,  geom%npz)
 
 1029 real(kind=
kind_real), 
intent(inout) :: ud(geom%isc:geom%iec,  geom%jsc:geom%jec+1,geom%npz)
 
 1030 real(kind=
kind_real), 
intent(inout) :: vd(geom%isc:geom%iec+1,geom%jsc:geom%jec,  geom%npz)
 
 1032 integer :: is ,ie , js ,je
 
 1033 integer :: npx, npy, npz
 
 1034 integer :: i,j,k, im2,jm2
 
 1036 real(kind=
kind_real) :: uatemp(geom%isd:geom%ied,geom%jsd:geom%jed,geom%npz)
 
 1037 real(kind=
kind_real) :: vatemp(geom%isd:geom%ied,geom%jsd:geom%jed,geom%npz)
 
 1039 real(kind=
kind_real) :: v3(geom%isc-1:geom%iec+1,geom%jsc-1:geom%jec+1,3)
 
 1040 real(kind=
kind_real) :: ue(geom%isc-1:geom%iec+1,geom%jsc  :geom%jec+1,3)    
 
 1041 real(kind=
kind_real) :: ve(geom%isc  :geom%iec+1,geom%jsc-1:geom%jec+1,3)    
 
 1042 real(kind=
kind_real), 
dimension(geom%isc:geom%iec):: ut1, ut2, ut3
 
 1043 real(kind=
kind_real), 
dimension(geom%jsc:geom%jec):: vt1, vt2, vt3
 
 1059 uatemp(is:ie,js:je,:) = ua
 
 1060 vatemp(is:ie,js:je,:) = va
 
 1062 call mpp_update_domains(uatemp, geom%domain, complete=.true.)
 
 1063 call mpp_update_domains(vatemp, geom%domain, complete=.true.)
 
 1069       v3(i,j,1) = uatemp(i,j,k)*geom%vlon(i,j,1) + vatemp(i,j,k)*geom%vlat(i,j,1)
 
 1070       v3(i,j,2) = uatemp(i,j,k)*geom%vlon(i,j,2) + vatemp(i,j,k)*geom%vlat(i,j,2)
 
 1071       v3(i,j,3) = uatemp(i,j,k)*geom%vlon(i,j,3) + vatemp(i,j,k)*geom%vlat(i,j,3)
 
 1077       ue(i,j,1) = v3(i,j-1,1) + v3(i,j,1)
 
 1078       ue(i,j,2) = v3(i,j-1,2) + v3(i,j,2)
 
 1079       ue(i,j,3) = v3(i,j-1,3) + v3(i,j,3)
 
 1085       ve(i,j,1) = v3(i-1,j,1) + v3(i,j,1)
 
 1086       ve(i,j,2) = v3(i-1,j,2) + v3(i,j,2)
 
 1087       ve(i,j,3) = v3(i-1,j,3) + v3(i,j,3)
 
 1095         vt1(j) = geom%edge_vect_w(j)*ve(i,j-1,1)+(1.-geom%edge_vect_w(j))*ve(i,j,1)
 
 1096         vt2(j) = geom%edge_vect_w(j)*ve(i,j-1,2)+(1.-geom%edge_vect_w(j))*ve(i,j,2)
 
 1097         vt3(j) = geom%edge_vect_w(j)*ve(i,j-1,3)+(1.-geom%edge_vect_w(j))*ve(i,j,3)
 
 1099         vt1(j) = geom%edge_vect_w(j)*ve(i,j+1,1)+(1.-geom%edge_vect_w(j))*ve(i,j,1)
 
 1100         vt2(j) = geom%edge_vect_w(j)*ve(i,j+1,2)+(1.-geom%edge_vect_w(j))*ve(i,j,2)
 
 1101         vt3(j) = geom%edge_vect_w(j)*ve(i,j+1,3)+(1.-geom%edge_vect_w(j))*ve(i,j,3)
 
 1111   if ( (ie+1)==npx ) 
then 
 1115         vt1(j) = geom%edge_vect_e(j)*ve(i,j-1,1)+(1.-geom%edge_vect_e(j))*ve(i,j,1)
 
 1116         vt2(j) = geom%edge_vect_e(j)*ve(i,j-1,2)+(1.-geom%edge_vect_e(j))*ve(i,j,2)
 
 1117         vt3(j) = geom%edge_vect_e(j)*ve(i,j-1,3)+(1.-geom%edge_vect_e(j))*ve(i,j,3)
 
 1119         vt1(j) = geom%edge_vect_e(j)*ve(i,j+1,1)+(1.-geom%edge_vect_e(j))*ve(i,j,1)
 
 1120         vt2(j) = geom%edge_vect_e(j)*ve(i,j+1,2)+(1.-geom%edge_vect_e(j))*ve(i,j,2)
 
 1121         vt3(j) = geom%edge_vect_e(j)*ve(i,j+1,3)+(1.-geom%edge_vect_e(j))*ve(i,j,3)
 
 1135         ut1(i) = geom%edge_vect_s(i)*ue(i-1,j,1)+(1.-geom%edge_vect_s(i))*ue(i,j,1)
 
 1136         ut2(i) = geom%edge_vect_s(i)*ue(i-1,j,2)+(1.-geom%edge_vect_s(i))*ue(i,j,2)
 
 1137         ut3(i) = geom%edge_vect_s(i)*ue(i-1,j,3)+(1.-geom%edge_vect_s(i))*ue(i,j,3)
 
 1139         ut1(i) = geom%edge_vect_s(i)*ue(i+1,j,1)+(1.-geom%edge_vect_s(i))*ue(i,j,1)
 
 1140         ut2(i) = geom%edge_vect_s(i)*ue(i+1,j,2)+(1.-geom%edge_vect_s(i))*ue(i,j,2)
 
 1141         ut3(i) = geom%edge_vect_s(i)*ue(i+1,j,3)+(1.-geom%edge_vect_s(i))*ue(i,j,3)
 
 1151   if ( (je+1)==npy ) 
then 
 1155         ut1(i) = geom%edge_vect_n(i)*ue(i-1,j,1)+(1.-geom%edge_vect_n(i))*ue(i,j,1)
 
 1156         ut2(i) = geom%edge_vect_n(i)*ue(i-1,j,2)+(1.-geom%edge_vect_n(i))*ue(i,j,2)
 
 1157         ut3(i) = geom%edge_vect_n(i)*ue(i-1,j,3)+(1.-geom%edge_vect_n(i))*ue(i,j,3)
 
 1159         ut1(i) = geom%edge_vect_n(i)*ue(i+1,j,1)+(1.-geom%edge_vect_n(i))*ue(i,j,1)
 
 1160         ut2(i) = geom%edge_vect_n(i)*ue(i+1,j,2)+(1.-geom%edge_vect_n(i))*ue(i,j,2)
 
 1161         ut3(i) = geom%edge_vect_n(i)*ue(i+1,j,3)+(1.-geom%edge_vect_n(i))*ue(i,j,3)
 
 1173       ud(i,j,k) = 0.5*( ue(i,j,1)*geom%es(1,i,j,1) +  &
 
 1174                         ue(i,j,2)*geom%es(2,i,j,1) +  &
 
 1175                         ue(i,j,3)*geom%es(3,i,j,1) )
 
 1181       vd(i,j,k) = 0.5*( ve(i,j,1)*geom%ew(1,i,j,2) +  &
 
 1182                         ve(i,j,2)*geom%ew(2,i,j,2) +  &
 
 1183                         ve(i,j,3)*geom%ew(3,i,j,2) )
 
 1193 subroutine a2d_ad(geom, ua_ad, va_ad, ud_ad, vd_ad)
 
 1197 real(kind=
kind_real), 
intent(inout) :: ua_ad(geom%isc:geom%iec,  geom%jsc:geom%jec,  geom%npz)
 
 1198 real(kind=
kind_real), 
intent(inout) :: va_ad(geom%isc:geom%iec,  geom%jsc:geom%jec,  geom%npz)
 
 1199 real(kind=
kind_real), 
intent(inout) :: ud_ad(geom%isc:geom%iec,  geom%jsc:geom%jec+1,geom%npz)
 
 1200 real(kind=
kind_real), 
intent(inout) :: vd_ad(geom%isc:geom%iec+1,geom%jsc:geom%jec  ,geom%npz)
 
 1202 integer :: is, ie, js, je
 
 1203 integer :: npx, npy, npz
 
 1204 integer :: i, j, k, im2, jm2
 
 1206 real(kind=
kind_real) :: uatemp(geom%isd:geom%ied, geom%jsd:geom%jed, geom%npz)
 
 1207 real(kind=
kind_real) :: vatemp(geom%isd:geom%ied, geom%jsd:geom%jed, geom%npz)
 
 1209 real(kind=
kind_real) :: uatemp_ad(geom%isd:geom%ied, geom%jsd:geom%jed, geom%npz)
 
 1210 real(kind=
kind_real) :: vatemp_ad(geom%isd:geom%ied, geom%jsd:geom%jed, geom%npz)
 
 1211 real(kind=
kind_real) :: v3_ad(geom%isc-1:geom%iec+1, geom%jsc-1:geom%jec+1, 3)
 
 1212 real(kind=
kind_real) :: ue_ad(geom%isc-1:geom%iec+1, geom%jsc:geom%jec+1, 3)
 
 1213 real(kind=
kind_real) :: ve_ad(geom%isc:geom%iec+1, geom%jsc-1:geom%jec+1, 3)
 
 1214 real(kind=
kind_real), 
dimension(geom%isc:geom%iec) :: ut1_ad, ut2_ad, ut3_ad
 
 1215 real(kind=
kind_real), 
dimension(geom%jsc:geom%jec) :: vt1_ad, vt2_ad, vt3_ad
 
 1229 uatemp(:, :, :) = 0.0
 
 1230 vatemp(:, :, :) = 0.0
 
 1248       temp_ad0 = 0.5*vd_ad(i, j, k)
 
 1249       ve_ad(i, j, 1) = ve_ad(i, j, 1) + geom%ew(1, i, j, 2)*temp_ad0
 
 1250       ve_ad(i, j, 2) = ve_ad(i, j, 2) + geom%ew(2, i, j, 2)*temp_ad0
 
 1251       ve_ad(i, j, 3) = ve_ad(i, j, 3) + geom%ew(3, i, j, 2)*temp_ad0
 
 1252       vd_ad(i, j, k) = 0.0_8
 
 1258       temp_ad = 0.5*ud_ad(i, j, k)
 
 1259       ue_ad(i, j, 1) = ue_ad(i, j, 1) + geom%es(1, i, j, 1)*temp_ad
 
 1260       ue_ad(i, j, 2) = ue_ad(i, j, 2) + geom%es(2, i, j, 1)*temp_ad
 
 1261       ue_ad(i, j, 3) = ue_ad(i, j, 3) + geom%es(3, i, j, 1)*temp_ad
 
 1262       ud_ad(i, j, k) = 0.0_8
 
 1266   if (je + 1 .eq. npy) 
then 
 1268       ut3_ad(i) = ut3_ad(i) + ue_ad(i, npy, 3)
 
 1269       ue_ad(i, npy, 3) = 0.0_8
 
 1270       ut2_ad(i) = ut2_ad(i) + ue_ad(i, npy, 2)
 
 1271       ue_ad(i, npy, 2) = 0.0_8
 
 1272       ut1_ad(i) = ut1_ad(i) + ue_ad(i, npy, 1)
 
 1273       ue_ad(i, npy, 1) = 0.0_8
 
 1276       if (i .le. im2) 
then 
 1277         ue_ad(i+1, npy, 3) = ue_ad(i+1, npy, 3) + geom%edge_vect_n(i)*ut3_ad(i)
 
 1278         ue_ad(i, npy, 3) = ue_ad(i, npy, 3) + (1.-geom%edge_vect_n(i))*ut3_ad(i)
 
 1280         ue_ad(i+1, npy, 2) = ue_ad(i+1, npy, 2) + geom%edge_vect_n(i)*ut2_ad(i)
 
 1281         ue_ad(i, npy, 2) = ue_ad(i, npy, 2) + (1.-geom%edge_vect_n(i))*ut2_ad(i)
 
 1283         ue_ad(i+1, npy, 1) = ue_ad(i+1, npy, 1) + geom%edge_vect_n(i)*ut1_ad(i)
 
 1284         ue_ad(i, npy, 1) = ue_ad(i, npy, 1) + (1.-geom%edge_vect_n(i))*ut1_ad(i)
 
 1287         ue_ad(i-1, npy, 3) = ue_ad(i-1, npy, 3) + geom%edge_vect_n(i)*ut3_ad(i)
 
 1288         ue_ad(i, npy, 3) = ue_ad(i, npy, 3) + (1.-geom%edge_vect_n(i))*ut3_ad(i)
 
 1290         ue_ad(i-1, npy, 2) = ue_ad(i-1, npy, 2) + geom%edge_vect_n(i)*ut2_ad(i)
 
 1291         ue_ad(i, npy, 2) = ue_ad(i, npy, 2) + (1.-geom%edge_vect_n(i))*ut2_ad(i)
 
 1293         ue_ad(i-1, npy, 1) = ue_ad(i-1, npy, 1) + geom%edge_vect_n(i)*ut1_ad(i)
 
 1294         ue_ad(i, npy, 1) = ue_ad(i, npy, 1) + (1.-geom%edge_vect_n(i))*ut1_ad(i)
 
 1302       ut3_ad(i) = ut3_ad(i) + ue_ad(i, 1, 3)
 
 1303       ue_ad(i, 1, 3) = 0.0_8
 
 1304       ut2_ad(i) = ut2_ad(i) + ue_ad(i, 1, 2)
 
 1305       ue_ad(i, 1, 2) = 0.0_8
 
 1306       ut1_ad(i) = ut1_ad(i) + ue_ad(i, 1, 1)
 
 1307       ue_ad(i, 1, 1) = 0.0_8
 
 1310       if (i .le. im2) 
then 
 1311         ue_ad(i+1, 1, 3) = ue_ad(i+1, 1, 3) + geom%edge_vect_s(i)*ut3_ad(i)
 
 1312         ue_ad(i, 1, 3) = ue_ad(i, 1, 3) + (1.-geom%edge_vect_s(i))*ut3_ad(i)
 
 1314         ue_ad(i+1, 1, 2) = ue_ad(i+1, 1, 2) + geom%edge_vect_s(i)*ut2_ad(i)
 
 1315         ue_ad(i, 1, 2) = ue_ad(i, 1, 2) + (1.-geom%edge_vect_s(i))*ut2_ad(i)
 
 1317         ue_ad(i+1, 1, 1) = ue_ad(i+1, 1, 1) + geom%edge_vect_s(i)*ut1_ad(i)
 
 1318         ue_ad(i, 1, 1) = ue_ad(i, 1, 1) + (1.-geom%edge_vect_s(i))*ut1_ad(i)
 
 1321         ue_ad(i-1, 1, 3) = ue_ad(i-1, 1, 3) + geom%edge_vect_s(i)*ut3_ad(i)
 
 1322         ue_ad(i, 1, 3) = ue_ad(i, 1, 3) + (1.-geom%edge_vect_s(i))*ut3_ad(i)
 
 1324         ue_ad(i-1, 1, 2) = ue_ad(i-1, 1, 2) + geom%edge_vect_s(i)*ut2_ad(i)
 
 1325         ue_ad(i, 1, 2) = ue_ad(i, 1, 2) + (1.-geom%edge_vect_s(i))*ut2_ad(i)
 
 1327         ue_ad(i-1, 1, 1) = ue_ad(i-1, 1, 1) + geom%edge_vect_s(i)*ut1_ad(i)
 
 1328         ue_ad(i, 1, 1) = ue_ad(i, 1, 1) + (1.-geom%edge_vect_s(i))*ut1_ad(i)
 
 1334   if (ie + 1 .eq. npx) 
then 
 1336       vt3_ad(j) = vt3_ad(j) + ve_ad(npx, j, 3)
 
 1337       ve_ad(npx, j, 3) = 0.0_8
 
 1338       vt2_ad(j) = vt2_ad(j) + ve_ad(npx, j, 2)
 
 1339       ve_ad(npx, j, 2) = 0.0_8
 
 1340       vt1_ad(j) = vt1_ad(j) + ve_ad(npx, j, 1)
 
 1341       ve_ad(npx, j, 1) = 0.0_8
 
 1344       if (j .le. jm2) 
then 
 1345         ve_ad(npx, j+1, 3) = ve_ad(npx, j+1, 3) + geom%edge_vect_e(j)*vt3_ad(j)
 
 1346         ve_ad(npx, j, 3) = ve_ad(npx, j, 3) + (1.-geom%edge_vect_e(j))*vt3_ad(j)
 
 1348         ve_ad(npx, j+1, 2) = ve_ad(npx, j+1, 2) + geom%edge_vect_e(j)*vt2_ad(j)
 
 1349         ve_ad(npx, j, 2) = ve_ad(npx, j, 2) + (1.-geom%edge_vect_e(j))*vt2_ad(j)
 
 1351         ve_ad(npx, j+1, 1) = ve_ad(npx, j+1, 1) + geom%edge_vect_e(j)*vt1_ad(j)
 
 1352         ve_ad(npx, j, 1) = ve_ad(npx, j, 1) + (1.-geom%edge_vect_e(j))*vt1_ad(j)
 
 1355         ve_ad(npx, j-1, 3) = ve_ad(npx, j-1, 3) + geom%edge_vect_e(j)*vt3_ad(j)
 
 1356         ve_ad(npx, j, 3) = ve_ad(npx, j, 3) + (1.-geom%edge_vect_e(j))*vt3_ad(j)
 
 1358         ve_ad(npx, j-1, 2) = ve_ad(npx, j-1, 2) + geom%edge_vect_e(j)*vt2_ad(j)
 
 1359         ve_ad(npx, j, 2) = ve_ad(npx, j, 2) + (1.-geom%edge_vect_e(j))*vt2_ad(j)
 
 1361         ve_ad(npx, j-1, 1) = ve_ad(npx, j-1, 1) + geom%edge_vect_e(j)*vt1_ad(j)
 
 1362         ve_ad(npx, j, 1) = ve_ad(npx, j, 1) + (1.-geom%edge_vect_e(j))*vt1_ad(j)
 
 1370       vt3_ad(j) = vt3_ad(j) + ve_ad(1, j, 3)
 
 1371       ve_ad(1, j, 3) = 0.0_8
 
 1372       vt2_ad(j) = vt2_ad(j) + ve_ad(1, j, 2)
 
 1373       ve_ad(1, j, 2) = 0.0_8
 
 1374       vt1_ad(j) = vt1_ad(j) + ve_ad(1, j, 1)
 
 1375       ve_ad(1, j, 1) = 0.0_8
 
 1378       if (j .le. jm2) 
then 
 1379         ve_ad(1, j+1, 3) = ve_ad(1, j+1, 3) + geom%edge_vect_w(j)*vt3_ad(j)
 
 1380         ve_ad(1, j, 3) = ve_ad(1, j, 3) + (1.-geom%edge_vect_w(j))*vt3_ad(j)
 
 1382         ve_ad(1, j+1, 2) = ve_ad(1, j+1, 2) + geom%edge_vect_w(j)*vt2_ad(j)
 
 1383         ve_ad(1, j, 2) = ve_ad(1, j, 2) + (1.-geom%edge_vect_w(j))*vt2_ad(j)
 
 1385         ve_ad(1, j+1, 1) = ve_ad(1, j+1, 1) + geom%edge_vect_w(j)*vt1_ad(j)
 
 1386         ve_ad(1, j, 1) = ve_ad(1, j, 1) + (1.-geom%edge_vect_w(j))*vt1_ad(j)
 
 1389         ve_ad(1, j-1, 3) = ve_ad(1, j-1, 3) + geom%edge_vect_w(j)*vt3_ad(j)
 
 1390         ve_ad(1, j, 3) = ve_ad(1, j, 3) + (1.-geom%edge_vect_w(j))*vt3_ad(j)
 
 1392         ve_ad(1, j-1, 2) = ve_ad(1, j-1, 2) + geom%edge_vect_w(j)*vt2_ad(j)
 
 1393         ve_ad(1, j, 2) = ve_ad(1, j, 2) + (1.-geom%edge_vect_w(j))*vt2_ad(j)
 
 1395         ve_ad(1, j-1, 1) = ve_ad(1, j-1, 1) + geom%edge_vect_w(j)*vt1_ad(j)
 
 1396         ve_ad(1, j, 1) = ve_ad(1, j, 1) + (1.-geom%edge_vect_w(j))*vt1_ad(j)
 
 1404       v3_ad(i-1, j, 3) = v3_ad(i-1, j, 3) + ve_ad(i, j, 3)
 
 1405       v3_ad(i, j, 3) = v3_ad(i, j, 3) + ve_ad(i, j, 3)
 
 1406       ve_ad(i, j, 3) = 0.0_8
 
 1407       v3_ad(i-1, j, 2) = v3_ad(i-1, j, 2) + ve_ad(i, j, 2)
 
 1408       v3_ad(i, j, 2) = v3_ad(i, j, 2) + ve_ad(i, j, 2)
 
 1409       ve_ad(i, j, 2) = 0.0_8
 
 1410       v3_ad(i-1, j, 1) = v3_ad(i-1, j, 1) + ve_ad(i, j, 1)
 
 1411       v3_ad(i, j, 1) = v3_ad(i, j, 1) + ve_ad(i, j, 1)
 
 1412       ve_ad(i, j, 1) = 0.0_8
 
 1418       v3_ad(i, j-1, 3) = v3_ad(i, j-1, 3) + ue_ad(i, j, 3)
 
 1419       v3_ad(i, j, 3) = v3_ad(i, j, 3) + ue_ad(i, j, 3)
 
 1420       ue_ad(i, j, 3) = 0.0_8
 
 1421       v3_ad(i, j-1, 2) = v3_ad(i, j-1, 2) + ue_ad(i, j, 2)
 
 1422       v3_ad(i, j, 2) = v3_ad(i, j, 2) + ue_ad(i, j, 2)
 
 1423       ue_ad(i, j, 2) = 0.0_8
 
 1424       v3_ad(i, j-1, 1) = v3_ad(i, j-1, 1) + ue_ad(i, j, 1)
 
 1425       v3_ad(i, j, 1) = v3_ad(i, j, 1) + ue_ad(i, j, 1)
 
 1426       ue_ad(i, j, 1) = 0.0_8
 
 1432       uatemp_ad(i, j, k) = uatemp_ad(i, j, k) + geom%vlon(i, j, 3)*v3_ad(i, j, 3)
 
 1433       vatemp_ad(i, j, k) = vatemp_ad(i, j, k) + geom%vlat(i, j, 3)*v3_ad(i, j, 3)
 
 1434       v3_ad(i, j, 3) = 0.0_8
 
 1435       uatemp_ad(i, j, k) = uatemp_ad(i, j, k) + geom%vlon(i, j, 2)*v3_ad(i, j, 2)
 
 1436       vatemp_ad(i, j, k) = vatemp_ad(i, j, k) + geom%vlat(i, j, 2)*v3_ad(i, j, 2)
 
 1437       v3_ad(i, j, 2) = 0.0_8
 
 1438       uatemp_ad(i, j, k) = uatemp_ad(i, j, k) + geom%vlon(i, j, 1)*v3_ad(i, j, 1)
 
 1439       vatemp_ad(i, j, k) = vatemp_ad(i, j, k) + geom%vlat(i, j, 1)*v3_ad(i, j, 1)
 
 1440       v3_ad(i, j, 1) = 0.0_8
 
 1445 call mpp_update_domains_adm(vatemp, vatemp_ad, geom%domain, complete=.true.)
 
 1446 call mpp_update_domains_adm(uatemp, uatemp_ad, geom%domain, complete=.true.)
 
 1448 va_ad = va_ad + vatemp_ad(is:ie, js:je, :)
 
 1449 ua_ad = ua_ad + uatemp_ad(is:ie, js:je, :)
 
 1455 subroutine d2a(geom, u_comp, v_comp, ua_comp, va_comp)
 
 1460 real(kind=
kind_real), 
intent(inout) ::  u_comp(geom%isc:geom%iec  ,geom%jsc:geom%jec+1,geom%npz)
 
 1461 real(kind=
kind_real), 
intent(inout) ::  v_comp(geom%isc:geom%iec+1,geom%jsc:geom%jec  ,geom%npz)
 
 1462 real(kind=
kind_real), 
intent(inout) :: ua_comp(geom%isc:geom%iec  ,geom%jsc:geom%jec  ,geom%npz)
 
 1463 real(kind=
kind_real), 
intent(inout) :: va_comp(geom%isc:geom%iec  ,geom%jsc:geom%jec  ,geom%npz)
 
 1467 real(kind=
kind_real) :: utmp(geom%isc:geom%iec,  geom%jsc:geom%jec+1)
 
 1468 real(kind=
kind_real) :: vtmp(geom%isc:geom%iec+1,geom%jsc:geom%jec)
 
 1469 real(kind=
kind_real) :: wu(geom%isc:geom%iec,  geom%jsc:geom%jec+1)
 
 1470 real(kind=
kind_real) :: wv(geom%isc:geom%iec+1,geom%jsc:geom%jec)
 
 1472 real(kind=
kind_real) ::  u(geom%isd:geom%ied  ,geom%jsd:geom%jed+1,geom%npz)
 
 1473 real(kind=
kind_real) ::  v(geom%isd:geom%ied+1,geom%jsd:geom%jed  ,geom%npz)
 
 1474 real(kind=
kind_real) :: ua(geom%isd:geom%ied  ,geom%jsd:geom%jed  ,geom%npz)
 
 1475 real(kind=
kind_real) :: va(geom%isd:geom%ied  ,geom%jsd:geom%jed  ,geom%npz)
 
 1477 real(kind=
kind_real) :: ebuffery(geom%jsc:geom%jec,1:geom%npz)
 
 1478 real(kind=
kind_real) :: nbufferx(geom%isc:geom%iec,1:geom%npz)
 
 1479 real(kind=
kind_real) :: wbuffery(geom%jsc:geom%jec,1:geom%npz)
 
 1480 real(kind=
kind_real) :: sbufferx(geom%isc:geom%iec,1:geom%npz)
 
 1483 integer :: is,  ie,  js,  je, npx, npy, npz
 
 1497 u(is:ie  ,js:je+1,:) = u_comp
 
 1498 v(is:ie+1,js:je  ,:) = v_comp
 
 1501 ebuffery = 0.0_kind_real
 
 1502 nbufferx = 0.0_kind_real
 
 1503 wbuffery = 0.0_kind_real
 
 1504 sbufferx = 0.0_kind_real
 
 1505 call mpp_get_boundary( u, v, geom%domain, &
 
 1506                        wbuffery=wbuffery, ebuffery=ebuffery, &
 
 1507                        sbufferx=sbufferx, nbufferx=nbufferx, &
 
 1508                        gridtype=dgrid_ne, complete=.true. )
 
 1511       u(i,je+1,k) = nbufferx(i,k)
 
 1516       v(ie+1,j,k) = ebuffery(j,k)
 
 1521 call mpp_update_domains(u, v, geom%domain, gridtype=dgrid_ne)
 
 1529   do j=max(2,js),min(npy-2,je)
 
 1530     do i=max(2,is),min(npx-2,ie)
 
 1531       utmp(i,j) = c2*(u(i,j-1,k)+u(i,j+2,k)) + c1*(u(i,j,k)+u(i,j+1,k))
 
 1532       vtmp(i,j) = c2*(v(i-1,j,k)+v(i+2,j,k)) + c1*(v(i,j,k)+v(i+1,j,k))
 
 1538       wv(i,1) = v(i,1,k)*geom%dy(i,1)
 
 1541       vtmp(i,1) = 2.*(wv(i,1) + wv(i+1,1)) / (geom%dy(i,1)+geom%dy(i+1,1))
 
 1542       utmp(i,1) = 2.*(u(i,1,k)*geom%dx(i,1) + u(i,2,k)*geom%dx(i,2))   &
 
 1543                    / (         geom%dx(i,1) +          geom%dx(i,2))
 
 1547   if ( (je+1)==npy   ) 
then 
 1550       wv(i,j) = v(i,j,k)*geom%dy(i,j)
 
 1553       vtmp(i,j) = 2.*(wv(i,j) + wv(i+1,j)) / (geom%dy(i,j)+geom%dy(i+1,j))
 
 1554       utmp(i,j) = 2.*(u(i,j,k)*geom%dx(i,j) + u(i,j+1,k)*geom%dx(i,j+1))   &
 
 1555                   / (         geom%dx(i,j) +            geom%dx(i,j+1))
 
 1562       wv(1,j) = v(1,j,k)*geom%dy(1,j)
 
 1563       wv(2,j) = v(2,j,k)*geom%dy(2,j)
 
 1566       wu(i,j) = u(i,j,k)*geom%dx(i,j)
 
 1569       utmp(i,j) = 2.*(wu(i,j) + wu(i,j+1))/(geom%dx(i,j)+geom%dx(i,j+1))
 
 1570       vtmp(i,j) = 2.*(wv(1,j) + wv(2,j  ))/(geom%dy(1,j)+geom%dy(2,j))
 
 1574   if ( (ie+1)==npx) 
then 
 1577       wv(i,  j) = v(i,  j,k)*geom%dy(i,  j)
 
 1578       wv(i+1,j) = v(i+1,j,k)*geom%dy(i+1,j)
 
 1581       wu(i,j) = u(i,j,k)*geom%dx(i,j)
 
 1584       utmp(i,j) = 2.*(wu(i,j) + wu(i,  j+1))/(geom%dx(i,j)+geom%dx(i,j+1))
 
 1585       vtmp(i,j) = 2.*(wv(i,j) + wv(i+1,j  ))/(geom%dy(i,j)+geom%dy(i+1,j))
 
 1592       ua(i,j,k) = geom%a11(i,j)*utmp(i,j) + geom%a12(i,j)*vtmp(i,j)
 
 1593       va(i,j,k) = geom%a21(i,j)*utmp(i,j) + geom%a22(i,j)*vtmp(i,j)
 
 1599 ua_comp = ua(is:ie,js:je,:)
 
 1600 va_comp = va(is:ie,js:je,:)
 
 1606 subroutine d2a_ad(geom, u_ad_comp, v_ad_comp, ua_ad_comp, va_ad_comp)
 
 1610 real(kind=
kind_real), 
intent(inout) ::  u_ad_comp(geom%isc:geom%iec,  geom%jsc:geom%jec+1,1:geom%npz)
 
 1611 real(kind=
kind_real), 
intent(inout) ::  v_ad_comp(geom%isc:geom%iec+1,geom%jsc:geom%jec,  1:geom%npz)
 
 1612 real(kind=
kind_real), 
intent(inout) :: ua_ad_comp(geom%isc:geom%iec,  geom%jsc:geom%jec,  1:geom%npz)
 
 1613 real(kind=
kind_real), 
intent(inout) :: va_ad_comp(geom%isc:geom%iec,  geom%jsc:geom%jec,  1:geom%npz)
 
 1615 real(kind=
kind_real) ::  u(geom%isd:geom%ied,  geom%jsd:geom%jed+1,geom%npz)
 
 1616 real(kind=
kind_real) ::  v(geom%isd:geom%ied+1,geom%jsd:geom%jed,  geom%npz)
 
 1617 real(kind=
kind_real) :: ua(geom%isd:geom%ied,  geom%jsd:geom%jed,  geom%npz)
 
 1618 real(kind=
kind_real) :: va(geom%isd:geom%ied,  geom%jsd:geom%jed,  geom%npz)
 
 1622 real(kind=
kind_real) :: utmp(geom%isc:geom%iec, geom%jsc:geom%jec+1)
 
 1623 real(kind=
kind_real) :: utmp_ad(geom%isc:geom%iec, geom%jsc:geom%jec+1)
 
 1624 real(kind=
kind_real) :: vtmp(geom%isc:geom%iec+1, geom%jsc:geom%jec)
 
 1625 real(kind=
kind_real) :: vtmp_ad(geom%isc:geom%iec+1, geom%jsc:geom%jec)
 
 1626 real(kind=
kind_real) :: wu(geom%isc:geom%iec, geom%jsc:geom%jec+1)
 
 1627 real(kind=
kind_real) :: wu_ad(geom%isc:geom%iec, geom%jsc:geom%jec+1)
 
 1628 real(kind=
kind_real) :: wv(geom%isc:geom%iec+1, geom%jsc:geom%jec)
 
 1629 real(kind=
kind_real) :: wv_ad(geom%isc:geom%iec+1, geom%jsc:geom%jec)
 
 1631 integer :: is, ie, js, je, npx, npy, npz
 
 1652 real(kind=
kind_real) ::  u_ad(geom%isd:geom%ied,  geom%jsd:geom%jed+1,1:geom%npz)
 
 1653 real(kind=
kind_real) ::  v_ad(geom%isd:geom%ied+1,geom%jsd:geom%jed,  1:geom%npz)
 
 1654 real(kind=
kind_real) :: ua_ad(geom%isd:geom%ied,  geom%jsd:geom%jed,  1:geom%npz)
 
 1655 real(kind=
kind_real) :: va_ad(geom%isd:geom%ied,  geom%jsd:geom%jed,  1:geom%npz)
 
 1657 real(kind=
kind_real) :: ebuffery(geom%jsc:geom%jec,1:geom%npz)
 
 1658 real(kind=
kind_real) :: nbufferx(geom%isc:geom%iec,1:geom%npz)
 
 1659 real(kind=
kind_real) :: wbuffery(geom%jsc:geom%jec,1:geom%npz)
 
 1660 real(kind=
kind_real) :: sbufferx(geom%isc:geom%iec,1:geom%npz)
 
 1670 ua_ad = 0.0_kind_real
 
 1671 va_ad = 0.0_kind_real
 
 1672 u_ad = 0.0_kind_real
 
 1673 v_ad = 0.0_kind_real
 
 1675 ua_ad(is:ie,js:je,:) = ua_ad_comp
 
 1676 va_ad(is:ie,js:je,:) = va_ad_comp
 
 1688   if (npy - 2 .gt. je) 
then 
 1700     if (npx - 2 .gt. ie) 
then 
 1706     call pushinteger4(i)
 
 1708     call pushinteger4(i - 1)
 
 1709     call pushinteger4(ad_from)
 
 1711   call pushinteger4(j - 1)
 
 1712   call pushinteger4(ad_from0)
 
 1714     call pushinteger4(i)
 
 1715     call pushcontrol1b(0)
 
 1717     call pushcontrol1b(1)
 
 1719   if (je + 1 .eq. npy) 
then 
 1721     call pushinteger4(i)
 
 1722     call pushcontrol1b(0)
 
 1724     call pushcontrol1b(1)
 
 1727     call pushinteger4(i)
 
 1729     call pushinteger4(j)
 
 1730     call pushcontrol1b(0)
 
 1732     call pushcontrol1b(1)
 
 1734   if (ie + 1 .eq. npx) 
then 
 1735     call pushinteger4(i)
 
 1737     call pushinteger4(j)
 
 1738     call pushcontrol1b(1)
 
 1740     call pushcontrol1b(0)
 
 1742   call pushinteger4(j)
 
 1744     call pushinteger4(i)
 
 1754       utmp_ad(i, j) = utmp_ad(i, j) + geom%a11(i, j)*ua_ad(i, j, k) + geom%a21(i, j)*va_ad(i, j, k)
 
 1755       vtmp_ad(i, j) = vtmp_ad(i, j) + geom%a12(i, j)*ua_ad(i, j, k) + geom%a22(i, j)*va_ad(i, j, k)
 
 1756       va_ad(i, j, k) = 0.0_8
 
 1757       ua_ad(i, j, k) = 0.0_8
 
 1762   call popcontrol1b(branch)
 
 1763   if (branch .ne. 0) 
then 
 1765       temp_ad5 = 2.*vtmp_ad(i, j)/(geom%dy(i, j)+geom%dy(i+1, j))
 
 1766       wv_ad(i, j) = wv_ad(i, j) + temp_ad5
 
 1767       wv_ad(i+1, j) = wv_ad(i+1, j) + temp_ad5
 
 1768       vtmp_ad(i, j) = 0.0_8
 
 1769       temp_ad6 = 2.*utmp_ad(i, j)/(geom%dx(i, j)+geom%dx(i, j+1))
 
 1770       wu_ad(i, j) = wu_ad(i, j) + temp_ad6
 
 1771       wu_ad(i, j+1) = wu_ad(i, j+1) + temp_ad6
 
 1772       utmp_ad(i, j) = 0.0_8
 
 1775       u_ad(i, j, k) = u_ad(i, j, k) + geom%dx(i, j)*wu_ad(i, j)
 
 1779       v_ad(i+1, j, k) = v_ad(i+1, j, k) + geom%dy(i+1, j)*wv_ad(i+1, j)
 
 1780       wv_ad(i+1, j) = 0.0_8
 
 1781       v_ad(i, j, k) = v_ad(i, j, k) + geom%dy(i, j)*wv_ad(i, j)
 
 1787   call popcontrol1b(branch)
 
 1788   if (branch .eq. 0) 
then 
 1790       temp_ad3 = 2.*vtmp_ad(i, j)/(geom%dy(1, j)+geom%dy(2, j))
 
 1791       wv_ad(1, j) = wv_ad(1, j) + temp_ad3
 
 1792       wv_ad(2, j) = wv_ad(2, j) + temp_ad3
 
 1793       vtmp_ad(i, j) = 0.0_8
 
 1794       temp_ad4 = 2.*utmp_ad(i, j)/(geom%dx(i, j)+geom%dx(i, j+1))
 
 1795       wu_ad(i, j) = wu_ad(i, j) + temp_ad4
 
 1796       wu_ad(i, j+1) = wu_ad(i, j+1) + temp_ad4
 
 1797       utmp_ad(i, j) = 0.0_8
 
 1800       u_ad(i, j, k) = u_ad(i, j, k) + geom%dx(i, j)*wu_ad(i, j)
 
 1804       v_ad(2, j, k) = v_ad(2, j, k) + geom%dy(2, j)*wv_ad(2, j)
 
 1806       v_ad(1, j, k) = v_ad(1, j, k) + geom%dy(1, j)*wv_ad(1, j)
 
 1812   call popcontrol1b(branch)
 
 1813   if (branch .eq. 0) 
then 
 1815       temp_ad1 = 2.*utmp_ad(i, j)/(geom%dx(i, j)+geom%dx(i, j+1))
 
 1816       u_ad(i, j, k) = u_ad(i, j, k) + geom%dx(i, j)*temp_ad1
 
 1817       u_ad(i, j+1, k) = u_ad(i, j+1, k) + geom%dx(i, j+1)*temp_ad1
 
 1818       utmp_ad(i, j) = 0.0_8
 
 1819       temp_ad2 = 2.*vtmp_ad(i, j)/(geom%dy(i, j)+geom%dy(i+1, j))
 
 1820       wv_ad(i, j) = wv_ad(i, j) + temp_ad2
 
 1821       wv_ad(i+1, j) = wv_ad(i+1, j) + temp_ad2
 
 1822       vtmp_ad(i, j) = 0.0_8
 
 1825       v_ad(i, j, k) = v_ad(i, j, k) + geom%dy(i, j)*wv_ad(i, j)
 
 1830   call popcontrol1b(branch)
 
 1831   if (branch .eq. 0) 
then 
 1833       temp_ad = 2.*utmp_ad(i, 1)/(geom%dx(i, 1)+geom%dx(i, 2))
 
 1834       u_ad(i, 1, k) = u_ad(i, 1, k) + geom%dx(i, 1)*temp_ad
 
 1835       u_ad(i, 2, k) = u_ad(i, 2, k) + geom%dx(i, 2)*temp_ad
 
 1836       utmp_ad(i, 1) = 0.0_8
 
 1837       temp_ad0 = 2.*vtmp_ad(i, 1)/(geom%dy(i, 1)+geom%dy(i+1, 1))
 
 1838       wv_ad(i, 1) = wv_ad(i, 1) + temp_ad0
 
 1839       wv_ad(i+1, 1) = wv_ad(i+1, 1) + temp_ad0
 
 1840       vtmp_ad(i, 1) = 0.0_8
 
 1843       v_ad(i, 1, k) = v_ad(i, 1, k) + geom%dy(i, 1)*wv_ad(i, 1)
 
 1848   call popinteger4(ad_from0)
 
 1849   call popinteger4(ad_to0)
 
 1850   do j=ad_to0,ad_from0,-1
 
 1851     call popinteger4(ad_from)
 
 1852     call popinteger4(ad_to)
 
 1853     do i=ad_to,ad_from,-1
 
 1854       v_ad(i-1, j, k) = v_ad(i-1, j, k) + c2*vtmp_ad(i, j)
 
 1855       v_ad(i+2, j, k) = v_ad(i+2, j, k) + c2*vtmp_ad(i, j)
 
 1856       v_ad(i, j, k) = v_ad(i, j, k) + c1*vtmp_ad(i, j)
 
 1857       v_ad(i+1, j, k) = v_ad(i+1, j, k) + c1*vtmp_ad(i, j)
 
 1858       vtmp_ad(i, j) = 0.0_8
 
 1859       u_ad(i, j-1, k) = u_ad(i, j-1, k) + c2*utmp_ad(i, j)
 
 1860       u_ad(i, j+2, k) = u_ad(i, j+2, k) + c2*utmp_ad(i, j)
 
 1861       u_ad(i, j, k) = u_ad(i, j, k) + c1*utmp_ad(i, j)
 
 1862       u_ad(i, j+1, k) = u_ad(i, j+1, k) + c1*utmp_ad(i, j)
 
 1863       utmp_ad(i, j) = 0.0_8
 
 1870 call mpp_update_domains_adm(u, u_ad, v, v_ad, geom%domain, gridtype=dgrid_ne)
 
 1873 ebuffery = 0.0_kind_real
 
 1874 nbufferx = 0.0_kind_real
 
 1875 wbuffery = 0.0_kind_real
 
 1876 sbufferx = 0.0_kind_real
 
 1880     nbufferx(i,k) = u_ad(i,je+1,k)
 
 1885     ebuffery(j,k) = v_ad(ie+1,j,k)
 
 1889 call mpp_get_boundary_ad( u_ad, v_ad, geom%domain, &
 
 1890                           wbuffery=wbuffery, ebuffery=ebuffery, sbufferx=sbufferx, nbufferx=nbufferx, &
 
 1891                           gridtype=dgrid_ne, complete=.true. )
 
 1894 u_ad_comp = u_ad(is:ie  ,js:je+1,:)
 
 1895 v_ad_comp = v_ad(is:ie+1,js:je  ,:)
 
 1905 real(kind=
kind_real), 
intent(inout) :: u(geom%isd:geom%ied  ,geom%jsd:geom%jed+1,1:geom%npz)
 
 1906 real(kind=
kind_real), 
intent(inout) :: v(geom%isd:geom%ied+1,geom%jsd:geom%jed  ,1:geom%npz)
 
 1907 logical, 
optional,    
intent(in)    :: fillhalo
 
 1909 integer :: isc, iec, jsc, jec, npz, i, j, k
 
 1910 real(kind=
kind_real) :: ebuffery(geom%jsc:geom%jec,1:geom%npz)
 
 1911 real(kind=
kind_real) :: nbufferx(geom%isc:geom%iec,1:geom%npz)
 
 1912 real(kind=
kind_real) :: wbuffery(geom%jsc:geom%jec,1:geom%npz)
 
 1913 real(kind=
kind_real) :: sbufferx(geom%isc:geom%iec,1:geom%npz)
 
 1929 ebuffery = 0.0_kind_real
 
 1930 nbufferx = 0.0_kind_real
 
 1931 wbuffery = 0.0_kind_real
 
 1932 sbufferx = 0.0_kind_real
 
 1933 call mpp_get_boundary( u, v, geom%domain, &
 
 1934                        wbuffery=wbuffery, ebuffery=ebuffery, &
 
 1935                        sbufferx=sbufferx, nbufferx=nbufferx, &
 
 1936                        gridtype=dgrid_ne, complete=.true. )
 
 1939       u(i,jec+1,k) = nbufferx(i,k)
 
 1944       v(iec+1,j,k) = ebuffery(j,k)
 
 1950 if (
present(fillhalo)) 
then 
 1952     call mpp_update_domains(u, v, geom%domain, gridtype=dgrid_ne)
 
 1964 real(kind=
kind_real), 
intent(inout) :: uc(geom%isd:geom%ied+1,geom%jsd:geom%jed  ,1:geom%npz)
 
 1965 real(kind=
kind_real), 
intent(inout) :: vc(geom%isd:geom%ied  ,geom%jsd:geom%jed+1,1:geom%npz)
 
 1966 logical, 
optional,    
intent(in)    :: fillhalo
 
 1968 integer :: isc, iec, jsc, jec, npz, i, j, k
 
 1969 real(kind=
kind_real) :: wbufferx(geom%jsc:geom%jec,1:geom%npz)
 
 1970 real(kind=
kind_real) :: sbuffery(geom%isc:geom%iec,1:geom%npz)
 
 1971 real(kind=
kind_real) :: ebufferx(geom%jsc:geom%jec,1:geom%npz)
 
 1972 real(kind=
kind_real) :: nbuffery(geom%isc:geom%iec,1:geom%npz)
 
 1988 ebufferx = 0.0_kind_real
 
 1989 nbuffery = 0.0_kind_real
 
 1990 wbufferx = 0.0_kind_real
 
 1991 sbuffery = 0.0_kind_real
 
 1993 call mpp_get_boundary(uc, vc, geom%domain, &
 
 1994                       wbufferx=wbufferx, ebufferx=ebufferx, &
 
 1995                       sbuffery=sbuffery, nbuffery=nbuffery, &
 
 1996                       gridtype=cgrid_ne, complete=.true.)
 
 1999       uc(iec+1,j,k) = ebufferx(j,k)
 
 2002       vc(i,jec+1,k) = nbuffery(i,k)
 
 2008 if (
present(fillhalo)) 
then 
 2010     call mpp_update_domains(uc, vc, geom%domain, gridtype=cgrid_ne)
 
 2022  real(kind=
kind_real), 
intent(in   ) ::  uc(geom%isd:geom%ied+1,geom%jsd:geom%jed  )
 
 2023  real(kind=
kind_real), 
intent(in   ) ::  vc(geom%isd:geom%ied  ,geom%jsd:geom%jed+1)
 
 2024  real(kind=
kind_real), 
intent(inout) ::  ut(geom%isd:geom%ied+1,geom%jsd:geom%jed  )
 
 2025  real(kind=
kind_real), 
intent(inout) ::  vt(geom%isd:geom%ied  ,geom%jsd:geom%jed+1)
 
 2029   integer :: is,js,ie,je,isd,jsd,ied,jed,npx,npy
 
 2044   if ( geom%grid_type < 3 ) 
then 
 2048            if(j/=0 .and. j/=1 .and. j/=(npy-1) .and. j/=npy) 
then 
 2050                 ut(i,j) = ( uc(i,j) - 0.25 * geom%cosa_u(i,j) *     &
 
 2051                     (vc(i-1,j)+vc(i,j)+vc(i-1,j+1)+vc(i,j+1)))*geom%rsin_u(i,j)
 
 2056            if( j/=1 .and. j/=npy ) 
then 
 2058                  vt(i,j) = ( vc(i,j) - 0.25 * geom%cosa_v(i,j) *     &
 
 2059                     (uc(i,j-1)+uc(i+1,j-1)+uc(i,j)+uc(i+1,j)))*geom%rsin_v(i,j)
 
 2067              if ( uc(1,j)*dt > 0. ) 
then 
 2068                 ut(1,j) = uc(1,j) / geom%sin_sg(0,j,3)
 
 2070                 ut(1,j) = uc(1,j) / geom%sin_sg(1,j,1)
 
 2073           do j=max(3,js), min(npy-2,je+1)
 
 2074              vt(0,j) = vc(0,j) - 0.25*geom%cosa_v(0,j)*   &
 
 2075                   (ut(0,j-1)+ut(1,j-1)+ut(0,j)+ut(1,j))
 
 2076              vt(1,j) = vc(1,j) - 0.25*geom%cosa_v(1,j)*   &
 
 2077                   (ut(1,j-1)+ut(2,j-1)+ut(1,j)+ut(2,j))
 
 2082        if ( (ie+1)==npx ) 
then 
 2084              if ( uc(npx,j)*dt > 0. ) 
then 
 2085                 ut(npx,j) = uc(npx,j) / geom%sin_sg(npx-1,j,3)
 
 2087                 ut(npx,j) = uc(npx,j) / geom%sin_sg(npx,j,1)
 
 2091            do j=max(3,js), min(npy-2,je+1)
 
 2092               vt(npx-1,j) = vc(npx-1,j) - 0.25*geom%cosa_v(npx-1,j)*   &
 
 2093                            (ut(npx-1,j-1)+ut(npx,j-1)+ut(npx-1,j)+ut(npx,j))
 
 2094               vt(npx,j) = vc(npx,j) - 0.25*geom%cosa_v(npx,j)*   &
 
 2095                          (ut(npx,j-1)+ut(npx+1,j-1)+ut(npx,j)+ut(npx+1,j))
 
 2103               if ( vc(i,1)*dt > 0. ) 
then 
 2104                    vt(i,1) = vc(i,1) / geom%sin_sg(i,0,4)
 
 2106                    vt(i,1) = vc(i,1) / geom%sin_sg(i,1,2)
 
 2110            do i=max(3,is),min(npx-2,ie+1)
 
 2111               ut(i,0) = uc(i,0) - 0.25*geom%cosa_u(i,0)*   &
 
 2112                        (vt(i-1,0)+vt(i,0)+vt(i-1,1)+vt(i,1))
 
 2113               ut(i,1) = uc(i,1) - 0.25*geom%cosa_u(i,1)*   &
 
 2114                        (vt(i-1,1)+vt(i,1)+vt(i-1,2)+vt(i,2))
 
 2119        if ( (je+1)==npy ) 
then 
 2121               if ( vc(i,npy)*dt > 0. ) 
then 
 2122                    vt(i,npy) = vc(i,npy) / geom%sin_sg(i,npy-1,4)
 
 2124                    vt(i,npy) = vc(i,npy) / geom%sin_sg(i,npy,2)
 
 2127            do i=max(3,is),min(npx-2,ie+1)
 
 2128               ut(i,npy-1) = uc(i,npy-1) - 0.25*geom%cosa_u(i,npy-1)*   &
 
 2129                            (vt(i-1,npy-1)+vt(i,npy-1)+vt(i-1,npy)+vt(i,npy))
 
 2130               ut(i,npy) = uc(i,npy) - 0.25*geom%cosa_u(i,npy)*   &
 
 2131                          (vt(i-1,npy)+vt(i,npy)+vt(i-1,npy+1)+vt(i,npy+1))
 
 2144         if( geom%sw_corner ) 
then 
 2145             damp = 1. / (1.-0.0625*geom%cosa_u(2,0)*geom%cosa_v(1,0))
 
 2146             ut(2,0) = (uc(2,0)-0.25*geom%cosa_u(2,0)*(vt(1,1)+vt(2,1)+vt(2,0) +vc(1,0) -   &
 
 2147                       0.25*geom%cosa_v(1,0)*(ut(1,0)+ut(1,-1)+ut(2,-1))) ) * damp
 
 2148             damp = 1. / (1.-0.0625*geom%cosa_u(0,1)*geom%cosa_v(0,2))
 
 2149             vt(0,2) = (vc(0,2)-0.25*geom%cosa_v(0,2)*(ut(1,1)+ut(1,2)+ut(0,2)+uc(0,1) -   &
 
 2150                       0.25*geom%cosa_u(0,1)*(vt(0,1)+vt(-1,1)+vt(-1,2))) ) * damp
 
 2152             damp = 1. / (1.-0.0625*geom%cosa_u(2,1)*geom%cosa_v(1,2))
 
 2153             ut(2,1) = (uc(2,1)-0.25*geom%cosa_u(2,1)*(vt(1,1)+vt(2,1)+vt(2,2)+vc(1,2) -   &
 
 2154                       0.25*geom%cosa_v(1,2)*(ut(1,1)+ut(1,2)+ut(2,2))) ) * damp
 
 2156             vt(1,2) = (vc(1,2)-0.25*geom%cosa_v(1,2)*(ut(1,1)+ut(1,2)+ut(2,2)+uc(2,1) -   &
 
 2157                       0.25*geom%cosa_u(2,1)*(vt(1,1)+vt(2,1)+vt(2,2))) ) * damp
 
 2160         if( geom%se_corner ) 
then 
 2161             damp = 1. / (1. - 0.0625*geom%cosa_u(npx-1,0)*geom%cosa_v(npx-1,0))
 
 2162             ut(npx-1,0) = ( uc(npx-1,0)-0.25*geom%cosa_u(npx-1,0)*(   &
 
 2163                             vt(npx-1,1)+vt(npx-2,1)+vt(npx-2,0)+vc(npx-1,0) -   &
 
 2164                       0.25*geom%cosa_v(npx-1,0)*(ut(npx,0)+ut(npx,-1)+ut(npx-1,-1))) ) * damp
 
 2165             damp = 1. / (1. - 0.0625*geom%cosa_u(npx+1,1)*geom%cosa_v(npx,2))
 
 2166             vt(npx,  2) = ( vc(npx,2)-0.25*geom%cosa_v(npx,2)*(  &
 
 2167                             ut(npx,1)+ut(npx,2)+ut(npx+1,2)+uc(npx+1,1) -   &
 
 2168                       0.25*geom%cosa_u(npx+1,1)*(vt(npx,1)+vt(npx+1,1)+vt(npx+1,2))) ) * damp
 
 2170             damp = 1. / (1. - 0.0625*geom%cosa_u(npx-1,1)*geom%cosa_v(npx-1,2))
 
 2171             ut(npx-1,1) = ( uc(npx-1,1)-0.25*geom%cosa_u(npx-1,1)*(  &
 
 2172                             vt(npx-1,1)+vt(npx-2,1)+vt(npx-2,2)+vc(npx-1,2) -   &
 
 2173                       0.25*geom%cosa_v(npx-1,2)*(ut(npx,1)+ut(npx,2)+ut(npx-1,2))) ) * damp
 
 2174             vt(npx-1,2) = ( vc(npx-1,2)-0.25*geom%cosa_v(npx-1,2)*(  &
 
 2175                             ut(npx,1)+ut(npx,2)+ut(npx-1,2)+uc(npx-1,1) -   &
 
 2176                       0.25*geom%cosa_u(npx-1,1)*(vt(npx-1,1)+vt(npx-2,1)+vt(npx-2,2))) ) * damp
 
 2179         if( geom%ne_corner ) 
then 
 2180             damp = 1. / (1. - 0.0625*geom%cosa_u(npx-1,npy)*geom%cosa_v(npx-1,npy+1))
 
 2181             ut(npx-1,npy) = ( uc(npx-1,npy)-0.25*geom%cosa_u(npx-1,npy)*(   &
 
 2182                               vt(npx-1,npy)+vt(npx-2,npy)+vt(npx-2,npy+1)+vc(npx-1,npy+1) -   &
 
 2183                 0.25*geom%cosa_v(npx-1,npy+1)*(ut(npx,npy)+ut(npx,npy+1)+ut(npx-1,npy+1))) ) * damp
 
 2184             damp = 1. / (1. - 0.0625*geom%cosa_u(npx+1,npy-1)*geom%cosa_v(npx,npy-1))
 
 2185             vt(npx,  npy-1) = ( vc(npx,npy-1)-0.25*geom%cosa_v(npx,npy-1)*(   &
 
 2186                                 ut(npx,npy-1)+ut(npx,npy-2)+ut(npx+1,npy-2)+uc(npx+1,npy-1) -   &
 
 2187                 0.25*geom%cosa_u(npx+1,npy-1)*(vt(npx,npy)+vt(npx+1,npy)+vt(npx+1,npy-1))) ) * damp
 
 2189             damp = 1. / (1. - 0.0625*geom%cosa_u(npx-1,npy-1)*geom%cosa_v(npx-1,npy-1))
 
 2190             ut(npx-1,npy-1) = ( uc(npx-1,npy-1)-0.25*geom%cosa_u(npx-1,npy-1)*(  &
 
 2191                                 vt(npx-1,npy)+vt(npx-2,npy)+vt(npx-2,npy-1)+vc(npx-1,npy-1) -  &
 
 2192                 0.25*geom%cosa_v(npx-1,npy-1)*(ut(npx,npy-1)+ut(npx,npy-2)+ut(npx-1,npy-2))) ) * damp
 
 2193             vt(npx-1,npy-1) = ( vc(npx-1,npy-1)-0.25*geom%cosa_v(npx-1,npy-1)*(  &
 
 2194                                 ut(npx,npy-1)+ut(npx,npy-2)+ut(npx-1,npy-2)+uc(npx-1,npy-1) -  &
 
 2195                 0.25*geom%cosa_u(npx-1,npy-1)*(vt(npx-1,npy)+vt(npx-2,npy)+vt(npx-2,npy-1))) ) * damp
 
 2198         if( geom%nw_corner ) 
then 
 2199             damp = 1. / (1. - 0.0625*geom%cosa_u(2,npy)*geom%cosa_v(1,npy+1))
 
 2200             ut(2,npy) = ( uc(2,npy)-0.25*geom%cosa_u(2,npy)*(   &
 
 2201                           vt(1,npy)+vt(2,npy)+vt(2,npy+1)+vc(1,npy+1) -   &
 
 2202                       0.25*geom%cosa_v(1,npy+1)*(ut(1,npy)+ut(1,npy+1)+ut(2,npy+1))) ) * damp
 
 2203             damp = 1. / (1. - 0.0625*geom%cosa_u(0,npy-1)*geom%cosa_v(0,npy-1))
 
 2204             vt(0,npy-1) = ( vc(0,npy-1)-0.25*geom%cosa_v(0,npy-1)*(  &
 
 2205                             ut(1,npy-1)+ut(1,npy-2)+ut(0,npy-2)+uc(0,npy-1) -   &
 
 2206                       0.25*geom%cosa_u(0,npy-1)*(vt(0,npy)+vt(-1,npy)+vt(-1,npy-1))) ) * damp
 
 2208             damp = 1. / (1. - 0.0625*geom%cosa_u(2,npy-1)*geom%cosa_v(1,npy-1))
 
 2209             ut(2,npy-1) = ( uc(2,npy-1)-0.25*geom%cosa_u(2,npy-1)*(  &
 
 2210                             vt(1,npy)+vt(2,npy)+vt(2,npy-1)+vc(1,npy-1) -   &
 
 2211                       0.25*geom%cosa_v(1,npy-1)*(ut(1,npy-1)+ut(1,npy-2)+ut(2,npy-2))) ) * damp
 
 2213             vt(1,npy-1) = ( vc(1,npy-1)-0.25*geom%cosa_v(1,npy-1)*(  &
 
 2214                             ut(1,npy-1)+ut(1,npy-2)+ut(2,npy-2)+uc(2,npy-1) -   &
 
 2215                       0.25*geom%cosa_u(2,npy-1)*(vt(1,npy)+vt(2,npy)+vt(2,npy-1))) ) * damp
 
 2238 subroutine ctoa(geom, uc, vc, ua, va)
 
 2242  real(kind=
kind_real), 
intent(in)  :: uc(geom%isd:geom%ied+1,geom%jsd:geom%jed  )    
 
 2243  real(kind=
kind_real), 
intent(in)  :: vc(geom%isd:geom%ied  ,geom%jsd:geom%jed+1)    
 
 2244  real(kind=
kind_real), 
intent(out) :: ua(geom%isd:geom%ied  ,geom%jsd:geom%jed  )    
 
 2245  real(kind=
kind_real), 
intent(out) :: va(geom%isd:geom%ied  ,geom%jsd:geom%jed  )    
 
 2248  real(kind=
kind_real) :: tmp1i(geom%isd:geom%ied+1)
 
 2249  real(kind=
kind_real) :: tmp2i(geom%isd:geom%ied+1)
 
 2250  real(kind=
kind_real) :: tmp1j(geom%jsd:geom%jed+1)
 
 2251  real(kind=
kind_real) :: tmp2j(geom%jsd:geom%jed+1)
 
 2253  do i=geom%isd,geom%ied
 
 2254     tmp1j(:) = 0.0_kind_real
 
 2255     tmp2j(:) = vc(i,:)*geom%dx(i,:)
 
 2257     va(i,geom%jsd:geom%jed) = tmp1j(geom%jsd+1:geom%jed+1)/geom%dxa(i,geom%jsd:geom%jed)
 
 2260  do j=geom%jsd,geom%jed
 
 2261     tmp1i(:) = 0.0_kind_real
 
 2262     tmp2i(:) = uc(:,j)*geom%dy(:,j)
 
 2264     ua(geom%isd:geom%ied,j) = tmp1i(geom%isd+1:geom%ied+1)/geom%dya(geom%isd:geom%ied,j)
 
 2271 subroutine atod(geom, ua, va, u, v)
 
 2275  real(kind=
kind_real), 
intent(in)  :: ua(geom%isd:geom%ied  ,geom%jsd:geom%jed  )    
 
 2276  real(kind=
kind_real), 
intent(in)  :: va(geom%isd:geom%ied  ,geom%jsd:geom%jed  )    
 
 2277  real(kind=
kind_real), 
intent(out) ::  u(geom%isd:geom%ied  ,geom%jsd:geom%jed+1)    
 
 2278  real(kind=
kind_real), 
intent(out) ::  v(geom%isd:geom%ied+1,geom%jsd:geom%jed  )    
 
 2281  real(kind=
kind_real) :: tmp1i(geom%isd:geom%ied+1)
 
 2282  real(kind=
kind_real) :: tmp2i(geom%isd:geom%ied)
 
 2283  real(kind=
kind_real) :: tmp1j(geom%jsd:geom%jed+1)
 
 2284  real(kind=
kind_real) :: tmp2j(geom%jsd:geom%jed)
 
 2286  do j=geom%jsd+1,geom%jed
 
 2288     tmp2i(:) = va(:,j)*geom%dxa(:,j)
 
 2290     v(:,j) = tmp1i(:)/geom%dxc(:,j)
 
 2292  do i=geom%isd+1,geom%ied
 
 2294     tmp2j(:) = ua(i,:)*geom%dya(i,:)
 
 2296     u(i,:) = tmp1j(:)/geom%dyc(i,:)
 
 2306  integer,              
intent(in)  :: ifirst,ilast
 
 2307  real(kind=
kind_real), 
intent(in)  ::  qin(ifirst:ilast)
 
 2308  real(kind=
kind_real), 
intent(out) :: qout(ifirst:ilast)
 
 2312  qout(:) = 0.0_kind_real
 
 2314    qout(i) = 0.5_kind_real * (qin(i-1) + qin(i))