dye_example.F90

Go to the documentation of this file.

!> A tracer package for using dyes to diagnose regional flows.
module regional_dyes
 
! This file is part of MOM6. See LICENSE.md for the license.
 
use mom_diag_mediator,      only : diag_ctrl
use mom_error_handler,      only : mom_error, fatal, warning
use mom_file_parser,        only : get_param, log_param, log_version, param_file_type
use mom_forcing_type,       only : forcing
use mom_grid,               only : ocean_grid_type
use mom_hor_index,          only : hor_index_type
use mom_io,                 only : file_exists, read_data, slasher, vardesc, var_desc, query_vardesc
use mom_open_boundary,      only : ocean_obc_type
use mom_restart,            only : query_initialized, mom_restart_cs
use mom_sponge,             only : set_up_sponge_field, sponge_cs
use mom_time_manager,       only : time_type
use mom_tracer_registry,    only : register_tracer, tracer_registry_type
use mom_tracer_diabatic,    only : tracer_vertdiff, applytracerboundaryfluxesinout
use mom_tracer_z_init,      only : tracer_z_init
use mom_unit_scaling,       only : unit_scale_type
use mom_variables,          only : surface
use mom_verticalgrid,       only : verticalgrid_type
 
use coupler_types_mod,      only : coupler_type_set_data, ind_csurf
use atmos_ocean_fluxes_mod, only : aof_set_coupler_flux
 
implicit none ; private
 
#include <MOM_memory.h>
 
public register_dye_tracer, initialize_dye_tracer
public dye_tracer_column_physics, dye_tracer_surface_state
public dye_stock, regional_dyes_end
 
! A note on unit descriptions in comments: MOM6 uses units that can be rescaled for dimensional
! consistency testing. These are noted in comments with units like Z, H, L, and T, along with
! their mks counterparts with notation like "a velocity [Z T-1 ~> m s-1]".  If the units
! vary with the Boussinesq approximation, the Boussinesq variant is given first.
 
!> The control structure for the regional dyes tracer package
type, public :: dye_tracer_cs ; private
  integer :: ntr    !< The number of tracers that are actually used.
  logical :: coupled_tracers = .false.  !< These tracers are not offered to the coupler.
  real, allocatable, dimension(:) :: dye_source_minlon !< Minimum longitude of region dye will be injected.
  real, allocatable, dimension(:) :: dye_source_maxlon !< Maximum longitude of region dye will be injected.
  real, allocatable, dimension(:) :: dye_source_minlat !< Minimum latitude of region dye will be injected.
  real, allocatable, dimension(:) :: dye_source_maxlat !< Maximum latitude of region dye will be injected.
  real, allocatable, dimension(:) :: dye_source_mindepth !< Minimum depth of region dye will be injected [Z ~> m].
  real, allocatable, dimension(:) :: dye_source_maxdepth !< Maximum depth of region dye will be injected [Z ~> m].
  type(tracer_registry_type), pointer :: tr_reg => null() !< A pointer to the tracer registry
  real, pointer :: tr(:,:,:,:) => null() !< The array of tracers used in this subroutine, in g m-3?
 
  integer, allocatable, dimension(:) :: ind_tr !< Indices returned by aof_set_coupler_flux if it is used and the
                                               !! surface tracer concentrations are to be provided to the coupler.
 
  type(diag_ctrl), pointer :: diag => null() !< A structure that is used to
                                   !! regulate the timing of diagnostic output.
  type(mom_restart_cs), pointer :: restart_csp => null() !< A pointer to the restart control structure
 
  type(vardesc), allocatable :: tr_desc(:) !< Descriptions and metadata for the tracers
  logical :: tracers_may_reinit = .false. !< If true the tracers may be initialized if not found in a restart file
end type dye_tracer_cs
 
contains
 
!> This subroutine is used to register tracer fields and subroutines
!! to be used with MOM.
function register_dye_tracer(HI, GV, US, param_file, CS, tr_Reg, restart_CS)
  type(hor_index_type),       intent(in) :: hi   !< A horizontal index type structure.
  type(verticalgrid_type),    intent(in) :: gv   !< The ocean's vertical grid structure
  type(unit_scale_type),      intent(in) :: us   !< A dimensional unit scaling type
  type(param_file_type),      intent(in) :: param_file !< A structure to parse for run-time parameters
  type(dye_tracer_cs),        pointer    :: cs   !< A pointer that is set to point to the control
                                                 !! structure for this module
  type(tracer_registry_type), pointer    :: tr_reg !< A pointer that is set to point to the control
                                                 !! structure for the tracer advection and diffusion module.
  type(mom_restart_cs),       pointer    :: restart_cs !< A pointer to the restart control structure.
 
! Local variables
! This include declares and sets the variable "version".
#include "version_variable.h"
  character(len=40)  :: mdl = "regional_dyes" ! This module's name.
  character(len=200) :: inputdir ! The directory where the input files are.
  character(len=48)  :: var_name ! The variable's name.
  character(len=48)  :: desc_name ! The variable's descriptor.
  real, pointer :: tr_ptr(:,:,:) => null()
  logical :: register_dye_tracer
  integer :: isd, ied, jsd, jed, nz, m
  isd = hi%isd ; ied = hi%ied ; jsd = hi%jsd ; jed = hi%jed ; nz = gv%ke
 
  if (associated(cs)) then
    call mom_error(warning, "register_dye_tracer called with an "// &
                             "associated control structure.")
    return
  endif
  allocate(cs)
 
  ! Read all relevant parameters and write them to the model log.
  call log_version(param_file, mdl, version, "")
  call get_param(param_file, mdl, "NUM_DYE_TRACERS", cs%ntr, &
                 "The number of dye tracers in this run. Each tracer "//&
                 "should have a separate region.", default=0)
  allocate(cs%dye_source_minlon(cs%ntr), &
           cs%dye_source_maxlon(cs%ntr), &
           cs%dye_source_minlat(cs%ntr), &
           cs%dye_source_maxlat(cs%ntr), &
           cs%dye_source_mindepth(cs%ntr), &
           cs%dye_source_maxdepth(cs%ntr))
  allocate(cs%ind_tr(cs%ntr))
  allocate(cs%tr_desc(cs%ntr))
 
  cs%dye_source_minlon(:) = -1.e30
  call get_param(param_file, mdl, "DYE_SOURCE_MINLON", cs%dye_source_minlon, &
                 "This is the starting longitude at which we start injecting dyes.", &
                 fail_if_missing=.true.)
  if (minval(cs%dye_source_minlon(:)) < -1.e29) &
    call mom_error(fatal, "register_dye_tracer: Not enough values provided for DYE_SOURCE_MINLON ")
 
  cs%dye_source_maxlon(:) = -1.e30
  call get_param(param_file, mdl, "DYE_SOURCE_MAXLON", cs%dye_source_maxlon, &
                 "This is the ending longitude at which we finish injecting dyes.", &
                 fail_if_missing=.true.)
  if (minval(cs%dye_source_maxlon(:)) < -1.e29) &
    call mom_error(fatal, "register_dye_tracer: Not enough values provided for DYE_SOURCE_MAXLON ")
 
  cs%dye_source_minlat(:) = -1.e30
  call get_param(param_file, mdl, "DYE_SOURCE_MINLAT", cs%dye_source_minlat, &
                 "This is the starting latitude at which we start injecting dyes.", &
                 fail_if_missing=.true.)
  if (minval(cs%dye_source_minlat(:)) < -1.e29) &
    call mom_error(fatal, "register_dye_tracer: Not enough values provided for DYE_SOURCE_MINLAT ")
 
  cs%dye_source_maxlat(:) = -1.e30
  call get_param(param_file, mdl, "DYE_SOURCE_MAXLAT", cs%dye_source_maxlat, &
                 "This is the ending latitude at which we finish injecting dyes.", &
                 fail_if_missing=.true.)
  if (minval(cs%dye_source_maxlat(:)) < -1.e29) &
    call mom_error(fatal, "register_dye_tracer: Not enough values provided for DYE_SOURCE_MAXLAT ")
 
  cs%dye_source_mindepth(:) = -1.e30
  call get_param(param_file, mdl, "DYE_SOURCE_MINDEPTH", cs%dye_source_mindepth, &
                 "This is the minimum depth at which we inject dyes.", &
                 units="m", scale=us%m_to_Z, fail_if_missing=.true.)
  if (minval(cs%dye_source_mindepth(:)) < -1.e29*us%m_to_Z) &
    call mom_error(fatal, "register_dye_tracer: Not enough values provided for DYE_SOURCE_MINDEPTH")
 
  cs%dye_source_maxdepth(:) = -1.e30
  call get_param(param_file, mdl, "DYE_SOURCE_MAXDEPTH", cs%dye_source_maxdepth, &
                 "This is the maximum depth at which we inject dyes.", &
                 units="m", scale=us%m_to_Z, fail_if_missing=.true.)
  if (minval(cs%dye_source_maxdepth(:)) < -1.e29*us%m_to_Z) &
    call mom_error(fatal, "register_dye_tracer: Not enough values provided for DYE_SOURCE_MAXDEPTH ")
 
  allocate(cs%tr(isd:ied,jsd:jed,nz,cs%ntr)) ; cs%tr(:,:,:,:) = 0.0
 
  do m = 1, cs%ntr
    write(var_name(:),'(A,I3.3)') "dye",m
    write(desc_name(:),'(A,I3.3)') "Dye Tracer ",m
    cs%tr_desc(m) = var_desc(trim(var_name), "conc", trim(desc_name), caller=mdl)
 
    ! This is needed to force the compiler not to do a copy in the registration
    ! calls.  Curses on the designers and implementers of Fortran90.
    tr_ptr => cs%tr(:,:,:,m)
    call query_vardesc(cs%tr_desc(m), name=var_name, &
                       caller="register_dye_tracer")
    ! Register the tracer for horizontal advection, diffusion, and restarts.
    call register_tracer(tr_ptr, tr_reg, param_file, hi, gv, &
                         tr_desc=cs%tr_desc(m), registry_diags=.true., &
                         restart_cs=restart_cs, mandatory=.not.cs%tracers_may_reinit)
 
    !   Set coupled_tracers to be true (hard-coded above) to provide the surface
    ! values to the coupler (if any).  This is meta-code and its arguments will
    ! currently (deliberately) give fatal errors if it is used.
    if (cs%coupled_tracers) &
      cs%ind_tr(m) = aof_set_coupler_flux(trim(var_name)//'_flux', &
          flux_type=' ', implementation=' ', caller="register_dye_tracer")
  enddo
 
  cs%tr_Reg => tr_reg
  cs%restart_CSp => restart_cs
  register_dye_tracer = .true.
end function register_dye_tracer
 
!> This subroutine initializes the CS%ntr tracer fields in tr(:,:,:,:)
!! and it sets up the tracer output.
subroutine initialize_dye_tracer(restart, day, G, GV, h, diag, OBC, CS, sponge_CSp)
  logical,                            intent(in) :: restart !< .true. if the fields have already been
                                                            !! read from a restart file.
  type(time_type), target,            intent(in) :: day  !< Time of the start of the run.
  type(ocean_grid_type),              intent(in) :: g    !< The ocean's grid structure
  type(verticalgrid_type),            intent(in) :: gv   !< The ocean's vertical grid structure
  real, dimension(NIMEM_,NJMEM_,NKMEM_), intent(in) :: h !< Layer thicknesses [H ~> m or kg m-2]
  type(diag_ctrl), target,            intent(in) :: diag !< Structure used to regulate diagnostic output.
  type(ocean_obc_type),               pointer    :: obc  !< This open boundary condition type specifies
                                                         !! whether, where, and what open boundary
                                                         !! conditions are used.
  type(dye_tracer_cs),                pointer    :: cs   !< The control structure returned by a previous
                                                         !! call to register_dye_tracer.
  type(sponge_cs),                    pointer    :: sponge_csp    !< A pointer to the control structure
                                                                  !! for the sponges, if they are in use.
 
! Local variables
  character(len=24) :: name     ! A variable's name in a NetCDF file.
  character(len=72) :: longname ! The long name of that variable.
  character(len=48) :: units    ! The dimensions of the variable.
  character(len=48) :: flux_units ! The units for age tracer fluxes, either
                                ! years m3 s-1 or years kg s-1.
  logical :: ok
  integer :: i, j, k, m
  real    :: z_bot, z_center
 
  if (.not.associated(cs)) return
  if (cs%ntr < 1) return
 
  cs%diag => diag
 
  ! Establish location of source
  do m= 1, cs%ntr
    do j=g%jsd,g%jed ; do i=g%isd,g%ied
      ! A dye is set dependent on the center of the cell being inside the rectangular box.
      if (cs%dye_source_minlon(m)<g%geoLonT(i,j) .and. &
          cs%dye_source_maxlon(m)>=g%geoLonT(i,j) .and. &
          cs%dye_source_minlat(m)<g%geoLatT(i,j) .and. &
          cs%dye_source_maxlat(m)>=g%geoLatT(i,j) .and. &
          g%mask2dT(i,j) > 0.0 ) then
        z_bot = -g%bathyT(i,j)
        do k = gv%ke, 1, -1
          z_center = z_bot + 0.5*h(i,j,k)*gv%H_to_Z
          if ( z_center > -cs%dye_source_maxdepth(m) .and. &
               z_center < -cs%dye_source_mindepth(m) ) then
            cs%tr(i,j,k,m) = 1.0
          endif
          z_bot = z_bot + h(i,j,k)*gv%H_to_Z
        enddo
      endif
    enddo ; enddo
  enddo
 
end subroutine initialize_dye_tracer
 
!> This subroutine applies diapycnal diffusion and any other column
!! tracer physics or chemistry to the tracers from this file.
!! This is a simple example of a set of advected passive tracers.
!! The arguments to this subroutine are redundant in that
!!     h_new(k) = h_old(k) + ea(k) - eb(k-1) + eb(k) - ea(k+1)
subroutine dye_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, G, GV, US, CS, &
              evap_CFL_limit, minimum_forcing_depth)
  type(ocean_grid_type),   intent(in) :: g    !< The ocean's grid structure
  type(verticalgrid_type), intent(in) :: gv   !< The ocean's vertical grid structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                           intent(in) :: h_old !< Layer thickness before entrainment [H ~> m or kg m-2].
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                           intent(in) :: h_new !< Layer thickness after entrainment [H ~> m or kg m-2].
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                           intent(in) :: ea   !< an array to which the amount of fluid entrained
                                              !! from the layer above during this call will be
                                              !! added [H ~> m or kg m-2].
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                           intent(in) :: eb   !< an array to which the amount of fluid entrained
                                              !! from the layer below during this call will be
                                              !! added [H ~> m or kg m-2].
  type(forcing),           intent(in) :: fluxes !< A structure containing pointers to thermodynamic
                                              !! and tracer forcing fields.  Unused fields have NULL ptrs.
  real,                    intent(in) :: dt   !< The amount of time covered by this call [T ~> s]
  type(unit_scale_type),   intent(in) :: us   !< A dimensional unit scaling type
  type(dye_tracer_cs),     pointer    :: cs   !< The control structure returned by a previous
                                              !! call to register_dye_tracer.
  real,          optional, intent(in) :: evap_cfl_limit !< Limit on the fraction of the water that can
                                              !! be fluxed out of the top layer in a timestep [nondim]
  real,          optional, intent(in) :: minimum_forcing_depth !< The smallest depth over which
                                              !! fluxes can be applied [H ~> m or kg m-2]
 
! Local variables
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)) :: h_work ! Used so that h can be modified
  real :: sfc_val  ! The surface value for the tracers.
  real :: isecs_per_year  ! The number of seconds in a year.
  real :: year            ! The time in years.
  integer :: secs, days   ! Integer components of the time type.
  integer :: i, j, k, is, ie, js, je, nz, m
  real    :: z_bot, z_center
 
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = gv%ke
 
  if (.not.associated(cs)) return
  if (cs%ntr < 1) return
 
  if (present(evap_cfl_limit) .and. present(minimum_forcing_depth)) then
    do m=1,cs%ntr
      do k=1,nz ;do j=js,je ; do i=is,ie
        h_work(i,j,k) = h_old(i,j,k)
      enddo ; enddo ; enddo
      call applytracerboundaryfluxesinout(g, gv, cs%tr(:,:,:,m), dt, fluxes, h_work, &
                                          evap_cfl_limit, minimum_forcing_depth)
      call tracer_vertdiff(h_work, ea, eb, dt, cs%tr(:,:,:,m), g, gv)
    enddo
  else
    do m=1,cs%ntr
      call tracer_vertdiff(h_old, ea, eb, dt, cs%tr(:,:,:,m), g, gv)
    enddo
  endif
 
  do m=1,cs%ntr
    do j=g%jsd,g%jed ; do i=g%isd,g%ied
      ! A dye is set dependent on the center of the cell being inside the rectangular box.
      if (cs%dye_source_minlon(m)<g%geoLonT(i,j) .and. &
          cs%dye_source_maxlon(m)>=g%geoLonT(i,j) .and. &
          cs%dye_source_minlat(m)<g%geoLatT(i,j) .and. &
          cs%dye_source_maxlat(m)>=g%geoLatT(i,j) .and. &
          g%mask2dT(i,j) > 0.0 ) then
        z_bot = -g%bathyT(i,j)
        do k=nz,1,-1
          z_center = z_bot + 0.5*h_new(i,j,k)*gv%H_to_Z
          if ( z_center > -cs%dye_source_maxdepth(m) .and. &
               z_center < -cs%dye_source_mindepth(m) ) then
            cs%tr(i,j,k,m) = 1.0
          endif
          z_bot = z_bot + h_new(i,j,k)*gv%H_to_Z
        enddo
      endif
    enddo ; enddo
  enddo
 
end subroutine dye_tracer_column_physics
 
!> This function calculates the mass-weighted integral of all tracer stocks,
!! returning the number of stocks it has calculated.  If the stock_index
!! is present, only the stock corresponding to that coded index is returned.
function dye_stock(h, stocks, G, GV, CS, names, units, stock_index)
  real, dimension(NIMEM_,NJMEM_,NKMEM_), intent(in) :: h    !< Layer thicknesses [H ~> m or kg m-2]
  real, dimension(:),                 intent(out)   :: stocks !< the mass-weighted integrated amount of
                                                            !! each tracer, in kg times concentration units [kg conc].
  type(ocean_grid_type),              intent(in)    :: g    !< The ocean's grid structure
  type(verticalgrid_type),            intent(in)    :: gv   !< The ocean's vertical grid structure
  type(dye_tracer_cs),                pointer       :: cs   !< The control structure returned by a
                                                            !! previous call to register_dye_tracer.
  character(len=*), dimension(:),     intent(out)   :: names !< the names of the stocks calculated.
  character(len=*), dimension(:),     intent(out)   :: units !< the units of the stocks calculated.
  integer, optional,                  intent(in)    :: stock_index !< the coded index of a specific stock
                                                                   !! being sought.
  integer                                           :: dye_stock   !< Return value: the number of stocks
                                                                   !! calculated here.
 
! Local variables
  integer :: i, j, k, is, ie, js, je, nz, m
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = gv%ke
 
  dye_stock = 0
  if (.not.associated(cs)) return
  if (cs%ntr < 1) return
 
  if (present(stock_index)) then ; if (stock_index > 0) then
    ! Check whether this stock is available from this routine.
 
    ! No stocks from this routine are being checked yet.  Return 0.
    return
  endif ; endif
 
  do m=1,cs%ntr
    call query_vardesc(cs%tr_desc(m), name=names(m), units=units(m), caller="dye_stock")
    units(m) = trim(units(m))//" kg"
    stocks(m) = 0.0
    do k=1,nz ; do j=js,je ; do i=is,ie
      stocks(m) = stocks(m) + cs%tr(i,j,k,m) * &
                             (g%mask2dT(i,j) * g%US%L_to_m**2*g%areaT(i,j) * h(i,j,k))
    enddo ; enddo ; enddo
    stocks(m) = gv%H_to_kg_m2 * stocks(m)
  enddo
  dye_stock = cs%ntr
 
end function dye_stock
 
!> This subroutine extracts the surface fields from this tracer package that
!! are to be shared with the atmosphere in coupled configurations.
!! This particular tracer package does not report anything back to the coupler.
subroutine dye_tracer_surface_state(state, h, G, CS)
  type(ocean_grid_type),  intent(in)    :: g  !< The ocean's grid structure.
  type(surface),          intent(inout) :: state !< A structure containing fields that
                                              !! describe the surface state of the ocean.
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                          intent(in)    :: h  !< Layer thickness [H ~> m or kg m-2].
  type(dye_tracer_cs),    pointer       :: cs !< The control structure returned by a previous
                                              !! call to register_dye_tracer.
 
  ! This particular tracer package does not report anything back to the coupler.
  ! The code that is here is just a rough guide for packages that would.
 
  integer :: m, is, ie, js, je, isd, ied, jsd, jed
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
  isd = g%isd ; ied = g%ied ; jsd = g%jsd ; jed = g%jed
 
  if (.not.associated(cs)) return
 
  if (cs%coupled_tracers) then
    do m=1,cs%ntr
      !   This call loads the surface values into the appropriate array in the
      ! coupler-type structure.
      call coupler_type_set_data(cs%tr(:,:,1,m), cs%ind_tr(m), ind_csurf, &
                   state%tr_fields, idim=(/isd, is, ie, ied/), &
                   jdim=(/jsd, js, je, jed/) )
    enddo
  endif
 
end subroutine dye_tracer_surface_state
 
!> Clean up any allocated memory after the run.
subroutine regional_dyes_end(CS)
  type(dye_tracer_cs), pointer :: cs !< The control structure returned by a previous
                                     !! call to register_dye_tracer.
  integer :: m
 
  if (associated(cs)) then
    if (associated(cs%tr)) deallocate(cs%tr)
    deallocate(cs)
  endif
end subroutine regional_dyes_end
 
!> \namespace regional_dyes
!!
!!    This file contains an example of the code that is needed to set
!!  up and use a set (in this case two) of dynamically passive tracers
!!  for diagnostic purposes.  The tracers here are dye tracers which
!!  are set to 1 within the geographical region specified. The depth
!!  which a tracer is set is determined by calculating the depth from
!!  the seafloor upwards through the column.
 
end module regional_dyes