MOM_transcribe_grid.F90

Go to the documentation of this file.

module mom_transcribe_grid

!***********************************************************************
!*                   GNU General Public License                        *
!* This file is a part of MOM.                                         *
!*                                                                     *
!* MOM is free software; you can redistribute it and/or modify it and  *
!* are expected to follow the terms of the GNU General Public License  *
!* as published by the Free Software Foundation; either version 2 of   *
!* the License, or (at your option) any later version.                 *
!*                                                                     *
!* MOM is distributed in the hope that it will be useful, but WITHOUT  *
!* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY  *
!* or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public    *
!* License for more details.                                           *
!*                                                                     *
!* For the full text of the GNU General Public License,                *
!* write to: Free Software Foundation, Inc.,                           *
!*           675 Mass Ave, Cambridge, MA 02139, USA.                   *
!* or see:   http://www.gnu.org/licenses/gpl.html                      *
!***********************************************************************

use mom_domains, only : pass_var, pass_vector
use mom_domains, only : to_all, scalar_pair, cgrid_ne, agrid, bgrid_ne, corner
use mom_dyn_horgrid, only : dyn_horgrid_type, set_derived_dyn_horgrid
use mom_error_handler, only : mom_error, mom_mesg, fatal, warning
use mom_grid, only : ocean_grid_type, set_derived_metrics

implicit none ; private

public copy_dyngrid_to_mom_grid, copy_mom_grid_to_dyngrid

contains

!> Copies information from a dynamic (shared) horizontal grid type into an
!! ocean_grid_type.
subroutine copy_dyngrid_to_mom_grid(dG, oG)
  type(dyn_horgrid_type), intent(in)    :: dG  !< Common horizontal grid type
  type(ocean_grid_type),  intent(inout) :: oG  !< Ocean grid type

  integer :: isd, ied, jsd, jed      ! Common data domains.
  integer :: IsdB, IedB, JsdB, JedB  ! Common data domains.
  integer :: ido, jdo, Ido2, Jdo2    ! Indexing offsets between the grids.
  integer :: Igst, Jgst              ! Global starting indices.
  integer :: i, j

  ! MOM_grid_init and create_dyn_horgrid are called outside of this routine.
  ! This routine copies over the fields that were set by MOM_initialized_fixed.

  ! Determine the indexing offsets between the grids.
  ido = dg%idg_offset - og%idg_offset
  jdo = dg%jdg_offset - og%jdg_offset

  isd = max(og%isd, dg%isd+ido) ; jsd = max(og%jsd, dg%jsd+jdo)
  ied = min(og%ied, dg%ied+ido) ; jed = min(og%jed, dg%jed+jdo)
  isdb = max(og%IsdB, dg%IsdB+ido) ; jsdb = max(og%JsdB, dg%JsdB+jdo)
  iedb = min(og%IedB, dg%IedB+ido) ; jedb = min(og%JedB, dg%JedB+jdo)

  ! Check that the grids conform.
  if ((isd > og%isc) .or. (ied < og%ied) .or. (jsd > og%jsc) .or. (jed > og%jed)) &
    call mom_error(fatal, "copy_dyngrid_to_MOM_grid called with incompatible grids.")

  do i=isd,ied ; do j=jsd,jed
    og%geoLonT(i,j) = dg%geoLonT(i+ido,j+jdo)
    og%geoLatT(i,j) = dg%geoLatT(i+ido,j+jdo)
    og%dxT(i,j) = dg%dxT(i+ido,j+jdo)
    og%dyT(i,j) = dg%dyT(i+ido,j+jdo)
    og%areaT(i,j) = dg%areaT(i+ido,j+jdo)
    og%bathyT(i,j) = dg%bathyT(i+ido,j+jdo)

    og%dF_dx(i,j) = dg%dF_dx(i+ido,j+jdo)
    og%dF_dy(i,j) = dg%dF_dy(i+ido,j+jdo)
    og%sin_rot(i,j) = dg%sin_rot(i+ido,j+jdo)
    og%cos_rot(i,j) = dg%cos_rot(i+ido,j+jdo)
    og%mask2dT(i,j) = dg%mask2dT(i+ido,j+jdo)
  enddo ; enddo

  do i=isdb,iedb ; do j=jsd,jed
    og%geoLonCu(i,j) = dg%geoLonCu(i+ido,j+jdo)
    og%geoLatCu(i,j) = dg%geoLatCu(i+ido,j+jdo)
    og%dxCu(i,j) = dg%dxCu(i+ido,j+jdo)
    og%dyCu(i,j) = dg%dyCu(i+ido,j+jdo)
    og%dy_Cu(i,j) = dg%dy_Cu(i+ido,j+jdo)
    og%dy_Cu_obc(i,j) = dg%dy_Cu_obc(i+ido,j+jdo)

    og%mask2dCu(i,j) = dg%mask2dCu(i+ido,j+jdo)
    og%areaCu(i,j) = dg%areaCu(i+ido,j+jdo)
    og%IareaCu(i,j) = dg%IareaCu(i+ido,j+jdo)
  enddo ; enddo

  do i=isd,ied ; do j=jsdb,jedb
    og%geoLonCv(i,j) = dg%geoLonCv(i+ido,j+jdo)
    og%geoLatCv(i,j) = dg%geoLatCv(i+ido,j+jdo)
    og%dxCv(i,j) = dg%dxCv(i+ido,j+jdo)
    og%dyCv(i,j) = dg%dyCv(i+ido,j+jdo)
    og%dx_Cv(i,j) = dg%dx_Cv(i+ido,j+jdo)
    og%dx_Cv_obc(i,j) = dg%dx_Cv_obc(i+ido,j+jdo)

    og%mask2dCv(i,j) = dg%mask2dCv(i+ido,j+jdo)
    og%areaCv(i,j) = dg%areaCv(i+ido,j+jdo)
    og%IareaCv(i,j) = dg%IareaCv(i+ido,j+jdo)
  enddo ; enddo

  do i=isdb,iedb ; do j=jsdb,jedb
    og%geoLonBu(i,j) = dg%geoLonBu(i+ido,j+jdo)
    og%geoLatBu(i,j) = dg%geoLatBu(i+ido,j+jdo)
    og%dxBu(i,j) = dg%dxBu(i+ido,j+jdo)
    og%dyBu(i,j) = dg%dyBu(i+ido,j+jdo)
    og%areaBu(i,j) = dg%areaBu(i+ido,j+jdo)
    og%CoriolisBu(i,j) = dg%CoriolisBu(i+ido,j+jdo)
    og%mask2dBu(i,j) = dg%mask2dBu(i+ido,j+jdo)
  enddo ; enddo

  og%bathymetry_at_vel = dg%bathymetry_at_vel
  if (og%bathymetry_at_vel) then
    do i=isdb,iedb ; do j=jsd,jed
      og%Dblock_u(i,j) = dg%Dblock_u(i+ido,j+jdo)
      og%Dopen_u(i,j) = dg%Dopen_u(i+ido,j+jdo)
    enddo ; enddo
    do i=isd,ied ; do j=jsdb,jedb
      og%Dblock_v(i,j) = dg%Dblock_v(i+ido,j+jdo)
      og%Dopen_v(i,j) = dg%Dopen_v(i+ido,j+jdo)
    enddo ; enddo
  endif

  og%gridLonT(og%isg:og%ieg) = dg%gridLonT(dg%isg:dg%ieg)
  og%gridLatT(og%jsg:og%jeg) = dg%gridLatT(dg%jsg:dg%jeg)
  ! The more complicated logic here avoids segmentation faults if one grid uses
  ! global symmetric memory while the other does not.  Because a northeast grid
  ! convention is being used, the upper bounds for each array correspond.
  !   Note that the dynamic grid always uses symmetric memory.
  ido2 = dg%IegB-og%IegB ; igst = max(og%IsgB, (dg%isg-1)-ido2)
  jdo2 = dg%JegB-og%JegB ; jgst = max(og%JsgB, (dg%jsg-1)-jdo2)
  do i=igst,og%IegB ; og%gridLonB(i) = dg%gridLonB(i+ido2) ; enddo
  do j=jgst,og%JegB ; og%gridLatB(j) = dg%gridLatB(j+jdo2) ; enddo

  ! Copy various scalar variables and strings.
  og%x_axis_units = dg%x_axis_units ; og%y_axis_units = dg%y_axis_units
  og%areaT_global = dg%areaT_global ; og%IareaT_global = dg%IareaT_global
  og%south_lat = dg%south_lat ; og%west_lon  = dg%west_lon
  og%len_lat = dg%len_lat ; og%len_lon = dg%len_lon
  og%Rad_Earth = dg%Rad_Earth ; og%max_depth = dg%max_depth

! Update the halos in case the dynamic grid has smaller halos than the ocean grid.
  call pass_var(og%areaT, og%Domain)
  call pass_var(og%bathyT, og%Domain)
  call pass_var(og%geoLonT, og%Domain)
  call pass_var(og%geoLatT, og%Domain)
  call pass_vector(og%dxT, og%dyT, og%Domain, to_all+scalar_pair, agrid)
  call pass_vector(og%dF_dx, og%dF_dy, og%Domain, to_all, agrid)
  call pass_vector(og%cos_rot, og%sin_rot, og%Domain, to_all, agrid)
  call pass_var(og%mask2dT, og%Domain)

  call pass_vector(og%areaCu, og%areaCv, og%Domain, to_all+scalar_pair, cgrid_ne)
  call pass_vector(og%dyCu, og%dxCv, og%Domain, to_all+scalar_pair, cgrid_ne)
  call pass_vector(og%dxCu, og%dyCv, og%Domain, to_all+scalar_pair, cgrid_ne)
  call pass_vector(og%dy_Cu, og%dx_Cv, og%Domain, to_all+scalar_pair, cgrid_ne)
  call pass_vector(og%dy_Cu_obc, og%dx_Cv_obc, og%Domain, to_all+scalar_pair, cgrid_ne)
  call pass_vector(og%mask2dCu, og%mask2dCv, og%Domain, to_all+scalar_pair, cgrid_ne)
  call pass_vector(og%IareaCu, og%IareaCv, og%Domain, to_all+scalar_pair, cgrid_ne)
  call pass_vector(og%IareaCu, og%IareaCv, og%Domain, to_all+scalar_pair, cgrid_ne)
  call pass_vector(og%geoLatCu, og%geoLatCv, og%Domain, to_all+scalar_pair, cgrid_ne)

  call pass_var(og%areaBu, og%Domain, position=corner)
  call pass_var(og%geoLonBu, og%Domain, position=corner)
  call pass_var(og%geoLatBu, og%Domain, position=corner)
  call pass_vector(og%dxBu, og%dyBu, og%Domain, to_all+scalar_pair, bgrid_ne)
  call pass_var(og%CoriolisBu, og%Domain, position=corner)
  call pass_var(og%mask2dBu, og%Domain, position=corner)

  if (og%bathymetry_at_vel) then
    call pass_vector(og%Dblock_u, og%Dblock_v, og%Domain, to_all+scalar_pair, cgrid_ne)
    call pass_vector(og%Dopen_u, og%Dopen_v, og%Domain, to_all+scalar_pair, cgrid_ne)
  endif

  call set_derived_metrics(og)

end subroutine copy_dyngrid_to_mom_grid


!> Copies information from an ocean_grid_type into a dynamic (shared)
!! horizontal grid type.
subroutine copy_mom_grid_to_dyngrid(oG, dG)
  type(ocean_grid_type),  intent(in)    :: oG  !< Ocean grid type
  type(dyn_horgrid_type), intent(inout) :: dG  !< Common horizontal grid type

  integer :: isd, ied, jsd, jed      ! Common data domains.
  integer :: IsdB, IedB, JsdB, JedB  ! Common data domains.
  integer :: ido, jdo, Ido2, Jdo2    ! Indexing offsets between the grids.
  integer :: Igst, Jgst              ! Global starting indices.
  integer :: i, j

  ! MOM_grid_init and create_dyn_horgrid are called outside of this routine.
  ! This routine copies over the fields that were set by MOM_initialized_fixed.

  ! Determine the indexing offsets between the grids.
  ido = og%idG_offset - dg%idG_offset
  jdo = og%jdG_offset - dg%jdG_offset

  isd = max(dg%isd, og%isd+ido) ; jsd = max(dg%jsd, og%jsd+jdo)
  ied = min(dg%ied, og%ied+ido) ; jed = min(dg%jed, og%jed+jdo)
  isdb = max(dg%IsdB, og%IsdB+ido) ; jsdb = max(dg%JsdB, og%JsdB+jdo)
  iedb = min(dg%IedB, og%IedB+ido) ; jedb = min(dg%JedB, og%JedB+jdo)

  ! Check that the grids conform.
  if ((isd > dg%isc) .or. (ied < dg%ied) .or. (jsd > dg%jsc) .or. (jed > dg%jed)) &
    call mom_error(fatal, "copy_dyngrid_to_MOM_grid called with incompatible grids.")

  do i=isd,ied ; do j=jsd,jed
    dg%geoLonT(i,j) = og%geoLonT(i+ido,j+jdo)
    dg%geoLatT(i,j) = og%geoLatT(i+ido,j+jdo)
    dg%dxT(i,j) = og%dxT(i+ido,j+jdo)
    dg%dyT(i,j) = og%dyT(i+ido,j+jdo)
    dg%areaT(i,j) = og%areaT(i+ido,j+jdo)
    dg%bathyT(i,j) = og%bathyT(i+ido,j+jdo)

    dg%dF_dx(i,j) = og%dF_dx(i+ido,j+jdo)
    dg%dF_dy(i,j) = og%dF_dy(i+ido,j+jdo)
    dg%sin_rot(i,j) = og%sin_rot(i+ido,j+jdo)
    dg%cos_rot(i,j) = og%cos_rot(i+ido,j+jdo)
    dg%mask2dT(i,j) = og%mask2dT(i+ido,j+jdo)
  enddo ; enddo

  do i=isdb,iedb ; do j=jsd,jed
    dg%geoLonCu(i,j) = og%geoLonCu(i+ido,j+jdo)
    dg%geoLatCu(i,j) = og%geoLatCu(i+ido,j+jdo)
    dg%dxCu(i,j) = og%dxCu(i+ido,j+jdo)
    dg%dyCu(i,j) = og%dyCu(i+ido,j+jdo)
    dg%dy_Cu(i,j) = og%dy_Cu(i+ido,j+jdo)
    dg%dy_Cu_obc(i,j) = og%dy_Cu_obc(i+ido,j+jdo)

    dg%mask2dCu(i,j) = og%mask2dCu(i+ido,j+jdo)
    dg%areaCu(i,j) = og%areaCu(i+ido,j+jdo)
    dg%IareaCu(i,j) = og%IareaCu(i+ido,j+jdo)
  enddo ; enddo

  do i=isd,ied ; do j=jsdb,jedb
    dg%geoLonCv(i,j) = og%geoLonCv(i+ido,j+jdo)
    dg%geoLatCv(i,j) = og%geoLatCv(i+ido,j+jdo)
    dg%dxCv(i,j) = og%dxCv(i+ido,j+jdo)
    dg%dyCv(i,j) = og%dyCv(i+ido,j+jdo)
    dg%dx_Cv(i,j) = og%dx_Cv(i+ido,j+jdo)
    dg%dx_Cv_obc(i,j) = og%dx_Cv_obc(i+ido,j+jdo)

    dg%mask2dCv(i,j) = og%mask2dCv(i+ido,j+jdo)
    dg%areaCv(i,j) = og%areaCv(i+ido,j+jdo)
    dg%IareaCv(i,j) = og%IareaCv(i+ido,j+jdo)
  enddo ; enddo

  do i=isdb,iedb ; do j=jsdb,jedb
    dg%geoLonBu(i,j) = og%geoLonBu(i+ido,j+jdo)
    dg%geoLatBu(i,j) = og%geoLatBu(i+ido,j+jdo)
    dg%dxBu(i,j) = og%dxBu(i+ido,j+jdo)
    dg%dyBu(i,j) = og%dyBu(i+ido,j+jdo)
    dg%areaBu(i,j) = og%areaBu(i+ido,j+jdo)
    dg%CoriolisBu(i,j) = og%CoriolisBu(i+ido,j+jdo)
    dg%mask2dBu(i,j) = og%mask2dBu(i+ido,j+jdo)
  enddo ; enddo

  dg%bathymetry_at_vel = og%bathymetry_at_vel
  if (dg%bathymetry_at_vel) then
    do i=isdb,iedb ; do j=jsd,jed
      dg%Dblock_u(i,j) = og%Dblock_u(i+ido,j+jdo)
      dg%Dopen_u(i,j) = og%Dopen_u(i+ido,j+jdo)
    enddo ; enddo
    do i=isd,ied ; do j=jsdb,jedb
      dg%Dblock_v(i,j) = og%Dblock_v(i+ido,j+jdo)
      dg%Dopen_v(i,j) = og%Dopen_v(i+ido,j+jdo)
    enddo ; enddo
  endif

  dg%gridLonT(dg%isg:dg%ieg) = og%gridLonT(og%isg:og%ieg)
  dg%gridLatT(dg%jsg:dg%jeg) = og%gridLatT(og%jsg:og%jeg)

  ! The more complicated logic here avoids segmentation faults if one grid uses
  ! global symmetric memory while the other does not.  Because a northeast grid
  ! convention is being used, the upper bounds for each array correspond.
  !   Note that the dynamic grid always uses symmetric memory.
  ido2 = og%IegB-dg%IegB ; igst = max(dg%isg-1, og%IsgB-ido2)
  jdo2 = og%JegB-dg%JegB ; jgst = max(dg%jsg-1, og%JsgB-jdo2)
  do i=igst,dg%IegB ; dg%gridLonB(i) = og%gridLonB(i+ido2) ; enddo
  do j=jgst,dg%JegB ; dg%gridLatB(j) = og%gridLatB(j+jdo2) ; enddo

  ! Copy various scalar variables and strings.
  dg%x_axis_units = og%x_axis_units ; dg%y_axis_units = og%y_axis_units
  dg%areaT_global = og%areaT_global ; dg%IareaT_global = og%IareaT_global
  dg%south_lat = og%south_lat ; dg%west_lon  = og%west_lon
  dg%len_lat = og%len_lat ; dg%len_lon = og%len_lon
  dg%Rad_Earth = og%Rad_Earth ; dg%max_depth = og%max_depth

! Update the halos in case the dynamic grid has smaller halos than the ocean grid.
  call pass_var(dg%areaT, dg%Domain)
  call pass_var(dg%bathyT, dg%Domain)
  call pass_var(dg%geoLonT, dg%Domain)
  call pass_var(dg%geoLatT, dg%Domain)
  call pass_vector(dg%dxT, dg%dyT, dg%Domain, to_all+scalar_pair, agrid)
  call pass_vector(dg%dF_dx, dg%dF_dy, dg%Domain, to_all, agrid)
  call pass_vector(dg%cos_rot, dg%sin_rot, dg%Domain, to_all, agrid)
  call pass_var(dg%mask2dT, dg%Domain)

  call pass_vector(dg%areaCu, dg%areaCv, dg%Domain, to_all+scalar_pair, cgrid_ne)
  call pass_vector(dg%dyCu, dg%dxCv, dg%Domain, to_all+scalar_pair, cgrid_ne)
  call pass_vector(dg%dxCu, dg%dyCv, dg%Domain, to_all+scalar_pair, cgrid_ne)
  call pass_vector(dg%dy_Cu, dg%dx_Cv, dg%Domain, to_all+scalar_pair, cgrid_ne)
  call pass_vector(dg%dy_Cu_obc, dg%dx_Cv_obc, dg%Domain, to_all+scalar_pair, cgrid_ne)
  call pass_vector(dg%mask2dCu, dg%mask2dCv, dg%Domain, to_all+scalar_pair, cgrid_ne)
  call pass_vector(dg%IareaCu, dg%IareaCv, dg%Domain, to_all+scalar_pair, cgrid_ne)
  call pass_vector(dg%IareaCu, dg%IareaCv, dg%Domain, to_all+scalar_pair, cgrid_ne)
  call pass_vector(dg%geoLatCu, dg%geoLatCv, dg%Domain, to_all+scalar_pair, cgrid_ne)

  call pass_var(dg%areaBu, dg%Domain, position=corner)
  call pass_var(dg%geoLonBu, dg%Domain, position=corner)
  call pass_var(dg%geoLatBu, dg%Domain, position=corner)
  call pass_vector(dg%dxBu, dg%dyBu, dg%Domain, to_all+scalar_pair, bgrid_ne)
  call pass_var(dg%CoriolisBu, dg%Domain, position=corner)
  call pass_var(dg%mask2dBu, dg%Domain, position=corner)

  if (dg%bathymetry_at_vel) then
    call pass_vector(dg%Dblock_u, dg%Dblock_v, dg%Domain, to_all+scalar_pair, cgrid_ne)
    call pass_vector(dg%Dopen_u, dg%Dopen_v, dg%Domain, to_all+scalar_pair, cgrid_ne)
  endif

  call  set_derived_dyn_horgrid(dg)

end subroutine copy_mom_grid_to_dyngrid

end module mom_transcribe_grid