Detailed Description

A tracer package of ideal age tracers.

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).

Data Types
type	ideal_age_tracer_cs
	The control structure for the ideal_age_tracer package. More...

Functions/Subroutines
logical function, public	register_ideal_age_tracer (HI, GV, param_file, CS, tr_Reg, restart_CS)
	Register the ideal age tracer fields to be used with MOM. More...

subroutine, public	initialize_ideal_age_tracer (restart, day, G, GV, US, h, diag, OBC, CS, sponge_CSp)
	Sets the ideal age traces to their initial values and sets up the tracer output. More...

subroutine, public	ideal_age_tracer_column_physics (h_old, h_new, ea, eb, fluxes, dt, G, GV, US, CS, evap_CFL_limit, minimum_forcing_depth)
	Applies diapycnal diffusion, aging and regeneration at the surface to the ideal age tracers. More...

integer function, public	ideal_age_stock (h, stocks, G, GV, CS, names, units, stock_index)
	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. More...

subroutine, public	ideal_age_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	ideal_age_example_end (CS)
	Deallocate any memory associated with this tracer package. More...

Variables
integer, parameter	ntr_max = 3
	the maximum number of tracers in this module. More...

Function/Subroutine Documentation

◆ ideal_age_example_end()

subroutine, public ideal_age_example::ideal_age_example_end ( type(ideal_age_tracer_cs), pointer CS )

Deallocate any memory associated with this tracer package.

Parameters

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

Definition at line 455 of file ideal_age_example.F90.

   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

◆ ideal_age_stock()

integer function, public ideal_age_example::ideal_age_stock	(	real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	h,
		real, dimension(:), intent(out)	stocks,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(ideal_age_tracer_cs), pointer	CS,
		character(len=*), dimension(:), intent(out)	names,
		character(len=*), dimension(:), intent(out)	units,
		integer, intent(in), optional	stock_index
	)

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.

Parameters

[in]	g	The ocean's grid structure
[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]	gv	The ocean's vertical grid structure
	cs	The control structure returned by a previous call to register_ideal_age_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: The number of stocks calculated here.

Definition at line 375 of file ideal_age_example.F90.

   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%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
   ideal_age_stock = cs%ntr
  

References mom_io::query_vardesc().

Referenced by mom_tracer_flow_control::call_tracer_stocks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ideal_age_tracer_column_physics()

subroutine, public ideal_age_example::ideal_age_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(unit_scale_type), intent(in)	US,
		type(ideal_age_tracer_cs), pointer	CS,
		real, intent(in), optional	evap_CFL_limit,
		real, intent(in), optional	minimum_forcing_depth
	)

Applies diapycnal diffusion, aging and regeneration at the surface to the ideal age tracers.

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 [T ~> s]
[in]	us	A dimensional unit scaling type
	cs	The control structure returned by a previous call to register_ideal_age_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 [H ~> m or kg m-2]

Definition at line 286 of file ideal_age_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 [T ~> s]
   type(unit_scale_type),   intent(in) :: US   !< A dimensional unit scaling type
   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 [H ~> m or kg m-2]
 !   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 inverse of the amount of time in a year [T-1 ~> s-1]
   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*us%s_to_T)
   !   Set the surface value of tracer 1 to increase exponentially
   ! with a 30 year time scale.
   year = us%s_to_T*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
  

References mom_tracer_diabatic::applytracerboundaryfluxesinout(), and mom_tracer_diabatic::tracer_vertdiff().

Here is the call graph for this function:

◆ ideal_age_tracer_surface_state()

subroutine, public ideal_age_example::ideal_age_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(ideal_age_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_ideal_age_tracer.

Definition at line 424 of file ideal_age_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(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
  

◆ initialize_ideal_age_tracer()

subroutine, public ideal_age_example::initialize_ideal_age_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,
		type(unit_scale_type), intent(in)	US,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	h,
		type(diag_ctrl), intent(in), target	diag,
		type(ocean_obc_type), pointer	OBC,
		type(ideal_age_tracer_cs), pointer	CS,
		type(sponge_cs), pointer	sponge_CSp
	)

Sets the ideal age traces to their initial values and 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]	us	A dimensional unit scaling type
[in]	h	Layer thicknesses [H ~> m or kg m-2]
[in]	diag	A structure that is 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_ideal_age_tracer.
	sponge_csp	Pointer to the control structure for the sponges.

Definition at line 198 of file ideal_age_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
   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
  

References mom_error_handler::mom_error(), mom_io::query_vardesc(), and mom_tracer_z_init::tracer_z_init().

Here is the call graph for this function:

◆ register_ideal_age_tracer()

logical function, public ideal_age_example::register_ideal_age_tracer	(	type(hor_index_type), intent(in)	HI,
		type(verticalgrid_type), intent(in)	GV,
		type(param_file_type), intent(in)	param_file,
		type(ideal_age_tracer_cs), pointer	CS,
		type(tracer_registry_type), pointer	tr_Reg,
		type(mom_restart_cs), pointer	restart_CS
	)

Register the ideal age tracer fields to be used with MOM.

Parameters

[in]	hi	A horizontal index type structure
[in]	gv	The ocean's vertical grid structure
[in]	param_file	A structure to parse for run-time parameters
	cs	The control structure returned by a previous call to register_ideal_age_tracer.
	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 73 of file ideal_age_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(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, &
                          flux_scale=gv%H_to_m)
  
     !   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.

References atmos_ocean_fluxes_mod::aof_set_coupler_flux(), mom_error_handler::mom_error(), mom_io::query_vardesc(), mom_tracer_registry::register_tracer(), and mom_io::var_desc().

Here is the call graph for this function:

Variable Documentation

◆ ntr_max

integer, parameter ideal_age_example::ntr_max = 3

private

the maximum number of tracers in this module.

Definition at line 35 of file ideal_age_example.F90.

35 integer, parameter :: NTR_MAX = 3 !< the maximum number of tracers in this module.

Detailed Description

Data Types

Functions/Subroutines

Variables

Function/Subroutine Documentation

◆ ideal_age_example_end()

◆ ideal_age_stock()

◆ ideal_age_tracer_column_physics()

◆ ideal_age_tracer_surface_state()

◆ initialize_ideal_age_tracer()

◆ register_ideal_age_tracer()

Variable Documentation

◆ ntr_max