regional_dyes Module Reference

Detailed Description

A tracer package for using dyes to diagnose regional flows.

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.

Data Types
type	dye_tracer_cs
	The control structure for the regional dyes tracer package. More...

Functions/Subroutines
logical function, public	register_dye_tracer (HI, GV, US, param_file, CS, tr_Reg, restart_CS)
	This subroutine is used to register tracer fields and subroutines to be used with MOM. More...
subroutine, public	initialize_dye_tracer (restart, day, G, GV, h, diag, OBC, CS, sponge_CSp)
	This subroutine initializes the CSntr tracer fields in tr(:,:,:,:) and it sets up the tracer output. More...
subroutine, public	dye_tracer_column_physics (h_old, h_new, ea, eb, fluxes, dt, G, GV, CS, evap_CFL_limit, minimum_forcing_depth)
	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) More...
integer function, public	dye_stock (h, stocks, G, GV, CS, names, units, stock_index)
	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. More...
subroutine, public	dye_tracer_surface_state (state, h, G, CS)
	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. More...
subroutine, public	regional_dyes_end (CS)
	Clean up any allocated memory after the run. More...

Function/Subroutine Documentation

dye_stock()

integer function, public regional_dyes::dye_stock	(	real, dimension(nimem_,njmem_,nkmem_), intent(in)	h,
		real, dimension(:), intent(out)	stocks,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(dye_tracer_cs), pointer	CS,
		character(len=*), dimension(:), intent(out)	names,
		character(len=*), dimension(:), intent(out)	units,
		integer, intent(in), optional	stock_index
	)

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.

Parameters

[in]	h	Layer thicknesses [H ~> m or kg m-2]
[out]	stocks	the mass-weighted integrated amount of each tracer, in kg times concentration units [kg conc].
[in]	g	The ocean's grid structure
[in]	gv	The ocean's vertical grid structure
	cs	The control structure returned by a previous call to register_dye_tracer.
[out]	names	the names of the stocks calculated.
[out]	units	the units of the stocks calculated.
[in]	stock_index	the coded index of a specific stock being sought.

Returns

Return value: the number of stocks calculated here.

Definition at line 328 of file dye_example.F90.

  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%areaT(i,j) * h(i,j,k))
    enddo ; enddo ; enddo
    stocks(m) = gv%H_to_kg_m2 * stocks(m)
  enddo
  dye_stock = cs%ntr
 

dye_tracer_column_physics()

subroutine, public regional_dyes::dye_tracer_column_physics	(	real, dimension(szi_(g),szj_(g),szk_(g)), intent(in)	h_old,
		real, dimension(szi_(g),szj_(g),szk_(g)), intent(in)	h_new,
		real, dimension(szi_(g),szj_(g),szk_(g)), intent(in)	ea,
		real, dimension(szi_(g),szj_(g),szk_(g)), intent(in)	eb,
		type(forcing), intent(in)	fluxes,
		real, intent(in)	dt,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(dye_tracer_cs), pointer	CS,
		real, intent(in), optional	evap_CFL_limit,
		real, intent(in), optional	minimum_forcing_depth
	)

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)

Parameters

[in]	g	The ocean's grid structure
[in]	gv	The ocean's vertical grid structure
[in]	h_old	Layer thickness before entrainment [H ~> m or kg m-2].
[in]	h_new	Layer thickness after entrainment [H ~> m or kg m-2].
[in]	ea	an array to which the amount of fluid entrained
[in]	eb	an array to which the amount of fluid entrained
[in]	fluxes	A structure containing pointers to thermodynamic and tracer forcing fields. Unused fields have NULL ptrs.
[in]	dt	The amount of time covered by this call [s]
	cs	The control structure returned by a previous call to register_dye_tracer.
[in]	evap_cfl_limit	Limit on the fraction of the water that can be fluxed out of the top layer in a timestep [nondim]
[in]	minimum_forcing_depth	The smallest depth over which fluxes can be applied [m]

Definition at line 248 of file dye_example.F90.

  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 [s]
  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 [m]
 
! 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
 

dye_tracer_surface_state()

subroutine, public regional_dyes::dye_tracer_surface_state	(	type(surface), intent(inout)	state,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	h,
		type(ocean_grid_type), intent(in)	G,
		type(dye_tracer_cs), pointer	CS
	)

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.

Parameters

[in]	g	The ocean's grid structure.
[in,out]	state	A structure containing fields that describe the surface state of the ocean.
[in]	h	Layer thickness [H ~> m or kg m-2].
	cs	The control structure returned by a previous call to register_dye_tracer.

Definition at line 375 of file dye_example.F90.

  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
 

initialize_dye_tracer()

subroutine, public regional_dyes::initialize_dye_tracer	(	logical, intent(in)	restart,
		type(time_type), intent(in), target	day,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		real, dimension( : , : , : ), intent(in)	h,
		type(diag_ctrl), intent(in), target	diag,
		type(ocean_obc_type), pointer	OBC,
		type(dye_tracer_cs), pointer	CS,
		type(sponge_cs), pointer	sponge_CSp
	)

This subroutine initializes the CSntr tracer fields in tr(:,:,:,:) and it sets up the tracer output.

Parameters

[in]	restart	.true. if the fields have already been read from a restart file.
[in]	day	Time of the start of the run.
[in]	g	The ocean's grid structure
[in]	gv	The ocean's vertical grid structure
[in]	h	Layer thicknesses [H ~> m or kg m-2]
[in]	diag	Structure used to regulate diagnostic output.
	obc	This open boundary condition type specifies whether, where, and what open boundary conditions are used.
	cs	The control structure returned by a previous call to register_dye_tracer.
	sponge_csp	A pointer to the control structure for the sponges, if they are in use.

Definition at line 187 of file dye_example.F90.

  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
 

regional_dyes_end()

subroutine, public regional_dyes::regional_dyes_end

(

type(dye_tracer_cs), pointer

CS

)

Clean up any allocated memory after the run.

Parameters

cs	The control structure returned by a previous call to register_dye_tracer.

Definition at line 406 of file dye_example.F90.

  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

register_dye_tracer()

logical function, public regional_dyes::register_dye_tracer	(	type(hor_index_type), intent(in)	HI,
		type(verticalgrid_type), intent(in)	GV,
		type(unit_scale_type), intent(in)	US,
		type(param_file_type), intent(in)	param_file,
		type(dye_tracer_cs), pointer	CS,
		type(tracer_registry_type), pointer	tr_Reg,
		type(mom_restart_cs), pointer	restart_CS
	)

This subroutine is used to register tracer fields and subroutines to be used with MOM.

Parameters

[in]	hi	A horizontal index type structure.
[in]	gv	The ocean's vertical grid structure
[in]	us	A dimensional unit scaling type
[in]	param_file	A structure to parse for run-time parameters
	cs	A pointer that is set to point to the control structure for this module
	tr_reg	A pointer that is set to point to the control structure for the tracer advection and diffusion module.
	restart_cs	A pointer to the restart control structure.

Definition at line 69 of file dye_example.F90.

  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.