ideal_age_example.F90

!> A tracer package of ideal age tracers
module ideal_age_example
 
! 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, mom_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, time_type_to_real
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_ideal_age_tracer, initialize_ideal_age_tracer
public ideal_age_tracer_column_physics, ideal_age_tracer_surface_state
public ideal_age_stock, ideal_age_example_end
 
integer, parameter :: ntr_max = 3 !< the maximum number of tracers in this module.
 
!> The control structure for the ideal_age_tracer package
type, public :: ideal_age_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.
  integer :: nkml   !< The number of layers in the mixed layer.  The ideal
                    !1 age tracers are reset in the top nkml layers.
  character(len=200) :: ic_file !< The file in which the age-tracer initial values
                    !! can be found, or an empty string for internal initialization.
  logical :: z_ic_file !< If true, the IC_file is in Z-space.  The default is false.
  type(time_type), pointer :: time => null() !< A pointer to the ocean model's clock.
  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 package, in g m-3?
  real, dimension(NTR_MAX) :: ic_val = 0.0    !< The (uniform) initial condition value.
  real, dimension(NTR_MAX) :: young_val = 0.0 !< The value assigned to tr at the surface.
  real, dimension(NTR_MAX) :: land_val = -1.0 !< The value of tr used where land is masked out.
  real, dimension(NTR_MAX) :: sfc_growth_rate !< The exponential growth rate for the surface value [year-1].
  real, dimension(NTR_MAX) :: tracer_start_year !< The year in which tracers start aging, or at which the
                                              !! surface value equals young_val, in years.
  logical :: tracers_may_reinit  !< If true, these tracers be set up via the initialization code if
                                 !! they are not found in the restart files.
  logical :: tracer_ages(ntr_max) !< Indicates whether each tracer ages.
 
  integer, dimension(NTR_MAX) :: 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 controls structure
 
  type(vardesc) :: tr_desc(ntr_max) !< Descriptions and metadata for the tracers
end type ideal_age_tracer_cs
 
contains
 
!> Register the ideal age tracer fields to be used with MOM.
function register_ideal_age_tracer(HI, GV, 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(param_file_type),      intent(in) :: param_file !< A structure to parse for run-time parameters
  type(ideal_age_tracer_cs),  pointer    :: cs !< The control structure returned by a previous
                                               !! call to register_ideal_age_tracer.
  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
 
! This include declares and sets the variable "version".
#include "version_variable.h"
  character(len=40)  :: mdl = "ideal_age_example" ! This module's name.
  character(len=200) :: inputdir ! The directory where the input files are.
  character(len=48)  :: var_name ! The variable's name.
  real, pointer :: tr_ptr(:,:,:) => null()
  logical :: register_ideal_age_tracer
  logical :: do_ideal_age, do_vintage, do_ideal_age_dated
  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_ideal_age_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, "DO_IDEAL_AGE", do_ideal_age, &
                 "If true, use an ideal age tracer that is set to 0 age "//&
                 "in the mixed layer and ages at unit rate in the interior.", &
                 default=.true.)
  call get_param(param_file, mdl, "DO_IDEAL_VINTAGE", do_vintage, &
                 "If true, use an ideal vintage tracer that is set to an "//&
                 "exponentially increasing value in the mixed layer and "//&
                 "is conserved thereafter.", default=.false.)
  call get_param(param_file, mdl, "DO_IDEAL_AGE_DATED", do_ideal_age_dated, &
                 "If true, use an ideal age tracer that is everywhere 0 "//&
                 "before IDEAL_AGE_DATED_START_YEAR, but the behaves like "//&
                 "the standard ideal age tracer - i.e. is set to 0 age in "//&
                 "the mixed layer and ages at unit rate in the interior.", &
                 default=.false.)
 
 
  call get_param(param_file, mdl, "AGE_IC_FILE", cs%IC_file, &
                 "The file in which the age-tracer initial values can be "//&
                 "found, or an empty string for internal initialization.", &
                 default=" ")
  if ((len_trim(cs%IC_file) > 0) .and. (scan(cs%IC_file,'/') == 0)) then
    ! Add the directory if CS%IC_file is not already a complete path.
    call get_param(param_file, mdl, "INPUTDIR", inputdir, default=".")
    cs%IC_file = trim(slasher(inputdir))//trim(cs%IC_file)
    call log_param(param_file, mdl, "INPUTDIR/AGE_IC_FILE", cs%IC_file)
  endif
  call get_param(param_file, mdl, "AGE_IC_FILE_IS_Z", cs%Z_IC_file, &
                 "If true, AGE_IC_FILE is in depth space, not layer space", &
                 default=.false.)
  call get_param(param_file, mdl, "TRACERS_MAY_REINIT", cs%tracers_may_reinit, &
                 "If true, tracers may go through the initialization code "//&
                 "if they are not found in the restart files.  Otherwise "//&
                 "it is a fatal error if the tracers are not found in the "//&
                 "restart files of a restarted run.", default=.false.)
 
  cs%ntr = 0
  if (do_ideal_age) then
    cs%ntr = cs%ntr + 1 ; m = cs%ntr
    cs%tr_desc(m) = var_desc("age", "yr", "Ideal Age Tracer", cmor_field_name="agessc", caller=mdl)
    cs%tracer_ages(m) = .true. ; cs%sfc_growth_rate(m) = 0.0
    cs%IC_val(m) = 0.0 ; cs%young_val(m) = 0.0 ; cs%tracer_start_year(m) = 0.0
  endif
 
  if (do_vintage) then
    cs%ntr = cs%ntr + 1 ; m = cs%ntr
    cs%tr_desc(m) = var_desc("vintage", "yr", "Exponential Vintage Tracer", &
                            caller=mdl)
    cs%tracer_ages(m) = .false. ; cs%sfc_growth_rate(m) = 1.0/30.0
    cs%IC_val(m) = 0.0 ; cs%young_val(m) = 1e-20 ; cs%tracer_start_year(m) = 0.0
    call get_param(param_file, mdl, "IDEAL_VINTAGE_START_YEAR", cs%tracer_start_year(m), &
                 "The date at which the ideal vintage tracer starts.", &
                 units="years", default=0.0)
  endif
 
  if (do_ideal_age_dated) then
    cs%ntr = cs%ntr + 1 ; m = cs%ntr
    cs%tr_desc(m) = var_desc("age_dated","yr","Ideal Age Tracer with a Start Date",&
                            caller=mdl)
    cs%tracer_ages(m) = .true. ; cs%sfc_growth_rate(m) = 0.0
    cs%IC_val(m) = 0.0 ; cs%young_val(m) = 0.0 ; cs%tracer_start_year(m) = 0.0
    call get_param(param_file, mdl, "IDEAL_AGE_DATED_START_YEAR", cs%tracer_start_year(m), &
                 "The date at which the dated ideal age tracer starts.", &
                 units="years", default=0.0)
  endif
 
  allocate(cs%tr(isd:ied,jsd:jed,nz,cs%ntr)) ; cs%tr(:,:,:,:) = 0.0
 
  do m=1,cs%ntr
    ! 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_ideal_age_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_ideal_age_tracer")
  enddo
 
  cs%tr_Reg => tr_reg
  cs%restart_CSp => restart_cs
  register_ideal_age_tracer = .true.
end function register_ideal_age_tracer
 
!> Sets the ideal age traces to their initial values and sets up the tracer output
subroutine initialize_ideal_age_tracer(restart, day, G, GV, US, 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
  type(unit_scale_type),              intent(in) :: us   !< A dimensional unit scaling type
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                                      intent(in) :: h    !< Layer thicknesses [H ~> m or kg m-2]
  type(diag_ctrl),            target, intent(in) :: diag !< A structure that is 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(ideal_age_tracer_cs),          pointer    :: cs !< The control structure returned by a previous
                                                       !! call to register_ideal_age_tracer.
  type(sponge_cs),                    pointer    :: sponge_csp !< Pointer to the control structure for the sponges.
 
!   This subroutine initializes the CS%ntr tracer fields in tr(:,:,:,:)
! and it sets up the tracer output.
 
  ! 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.
  character(len=72) :: cmorname ! The CMOR name of that variable.
  logical :: ok
  integer :: i, j, k, is, ie, js, je, isd, ied, jsd, jed, nz, m
  integer :: isdb, iedb, jsdb, jedb
 
  if (.not.associated(cs)) return
  if (cs%ntr < 1) return
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = gv%ke
  isd = g%isd ; ied = g%ied ; jsd = g%jsd ; jed = g%jed
  isdb = g%IsdB ; iedb = g%IedB ; jsdb = g%JsdB ; jedb = g%JedB
 
  cs%Time => day
  cs%diag => diag
  cs%nkml = max(gv%nkml,1)
 
  do m=1,cs%ntr
    call query_vardesc(cs%tr_desc(m), name=name, &
                       caller="initialize_ideal_age_tracer")
    if ((.not.restart) .or. (cs%tracers_may_reinit .and. .not. &
        query_initialized(cs%tr(:,:,:,m), name, cs%restart_CSp))) then
 
      if (len_trim(cs%IC_file) > 0) then
  !  Read the tracer concentrations from a netcdf file.
        if (.not.file_exists(cs%IC_file, g%Domain)) &
          call mom_error(fatal, "initialize_ideal_age_tracer: "// &
                                 "Unable to open "//cs%IC_file)
 
        if (cs%Z_IC_file) then
          ok = tracer_z_init(cs%tr(:,:,:,m), h, cs%IC_file, name,&
                             g, us, -1e34, 0.0) ! CS%land_val(m))
          if (.not.ok) then
            ok = tracer_z_init(cs%tr(:,:,:,m), h, cs%IC_file, &
                     trim(name), g, us, -1e34, 0.0) ! CS%land_val(m))
            if (.not.ok) call mom_error(fatal,"initialize_ideal_age_tracer: "//&
                    "Unable to read "//trim(name)//" from "//&
                    trim(cs%IC_file)//".")
          endif
        else
          call mom_read_data(cs%IC_file, trim(name), cs%tr(:,:,:,m), g%Domain)
        endif
      else
        do k=1,nz ; do j=js,je ; do i=is,ie
          if (g%mask2dT(i,j) < 0.5) then
            cs%tr(i,j,k,m) = cs%land_val(m)
          else
            cs%tr(i,j,k,m) = cs%IC_val(m)
          endif
        enddo ; enddo ; enddo
      endif
 
    endif ! restart
  enddo ! Tracer loop
 
  if (associated(obc)) then
  ! Steal from updated DOME in the fullness of time.
  endif
 
end subroutine initialize_ideal_age_tracer
 
!> Applies diapycnal diffusion, aging and regeneration at the surface to the ideal age tracers
subroutine ideal_age_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, G, GV, 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 [s]
  type(ideal_age_tracer_cs), pointer  :: cs   !< The control structure returned by a previous
                                              !! call to register_ideal_age_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]
!   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)
  ! 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 :: i, j, k, is, ie, js, je, nz, m
  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
 
  isecs_per_year = 1.0 / (365.0*86400.0)
  !   Set the surface value of tracer 1 to increase exponentially
  ! with a 30 year time scale.
  year = time_type_to_real(cs%Time) * isecs_per_year
 
  do m=1,cs%ntr
    if (cs%sfc_growth_rate(m) == 0.0) then
      sfc_val = cs%young_val(m)
    else
      sfc_val = cs%young_val(m) * &
          exp((year-cs%tracer_start_year(m)) * cs%sfc_growth_rate(m))
    endif
    do k=1,cs%nkml ; do j=js,je ; do i=is,ie
      if (g%mask2dT(i,j) > 0.5) then
        cs%tr(i,j,k,m) = sfc_val
      else
        cs%tr(i,j,k,m) = cs%land_val(m)
      endif
    enddo ; enddo ; enddo
  enddo
  do m=1,cs%ntr ; if (cs%tracer_ages(m) .and. &
                      (year>=cs%tracer_start_year(m))) then
!$OMP parallel do default(none) shared(is,ie,js,je,CS,nz,G,dt,Isecs_per_year,m)
    do k=cs%nkml+1,nz ; do j=js,je ; do i=is,ie
      cs%tr(i,j,k,m) = cs%tr(i,j,k,m) + g%mask2dT(i,j)*dt*isecs_per_year
    enddo ; enddo ; enddo
  endif ; enddo
 
end subroutine ideal_age_tracer_column_physics
 
!> Calculates the mass-weighted integral of all tracer stocks, returning the number of stocks it
!! has calculated.  If stock_index is present, only the stock corresponding to that coded index is found.
function ideal_age_stock(h, stocks, G, GV, CS, names, units, stock_index)
  type(ocean_grid_type),              intent(in)    :: g    !< The ocean's grid structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                                      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(verticalgrid_type),            intent(in)    :: gv   !< The ocean's vertical grid structure
  type(ideal_age_tracer_cs),          pointer       :: cs   !< The control structure returned by a previous
                                                            !! call to register_ideal_age_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                                           :: ideal_age_stock !< The number of stocks calculated here.
! 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.
 
  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
 
  ideal_age_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="ideal_age_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
  ideal_age_stock = cs%ntr
 
end function ideal_age_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 ideal_age_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(ideal_age_tracer_cs), pointer    :: cs !< The control structure returned by a previous
                                              !! call to register_ideal_age_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 ideal_age_tracer_surface_state
 
!> Deallocate any memory associated with this tracer package
subroutine ideal_age_example_end(CS)
  type(ideal_age_tracer_cs), pointer :: cs !< The control structure returned by a previous
                                           !! call to register_ideal_age_tracer.
 
  integer :: m
 
  if (associated(cs)) then
    if (associated(cs%tr)) deallocate(cs%tr)
    deallocate(cs)
  endif
end subroutine ideal_age_example_end
 
!> \namespace ideal_age_example
!!
!!  Originally by Robert Hallberg, 2002
!!
!!    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 an ideal age tracer
!!  that ages at a rate of 1/year once it is isolated from the surface,
!!  and a vintage tracer, whose surface concentration grows exponen-
!!  with time with a 30-year timescale (similar to CFCs).
 
end module ideal_age_example