mom_tracer_flow_control Module Reference

Detailed Description

Orchestrates the registration and calling of tracer packages.

Data Types
type	tracer_flow_control_cs
	The control structure for orchestrating the calling of tracer packages. More...

Functions/Subroutines
subroutine, public	call_tracer_flux_init (verbosity)
	This subroutine carries out a series of calls to initialize the air-sea tracer fluxes, but it does not record the generated indicies, and it may be called before the ocean model has been initialized and may be called on non-ocean PEs. It is not necessary to call this routine for ocean-only runs, because the same calls are made again inside of the routines called by call_tracer_register. More...
subroutine, public	call_tracer_register (HI, GV, US, param_file, CS, tr_Reg, restart_CS)
	This subroutine determines which tracer packages are to be used and does the calls to register their tracers to be advected, diffused, and read from restarts. More...
subroutine, public	tracer_flow_control_init (restart, day, G, GV, US, h, param_file, diag, OBC, CS, sponge_CSp, ALE_sponge_CSp, tv)
	This subroutine calls all registered tracer initialization subroutines. More...
subroutine, public	get_chl_from_model (Chl_array, G, CS)
	This subroutine extracts the chlorophyll concentrations from the model state, if possible. More...
subroutine, public	call_tracer_set_forcing (sfc_state, fluxes, day_start, day_interval, G, CS)
	This subroutine calls the individual tracer modules' subroutines to specify or read quantities related to their surface forcing. More...
subroutine, public	call_tracer_column_fns (h_old, h_new, ea, eb, fluxes, Hml, dt, G, GV, US, tv, optics, CS, debug, evap_CFL_limit, minimum_forcing_depth)
	This subroutine calls all registered tracer column physics subroutines. More...
subroutine, public	call_tracer_stocks (h, stock_values, G, GV, CS, stock_names, stock_units, num_stocks, stock_index, got_min_max, global_min, global_max, xgmin, ygmin, zgmin, xgmax, ygmax, zgmax)
	This subroutine calls all registered tracer packages to enable them to add to the surface state returned to the coupler. These routines are optional. More...
subroutine	store_stocks (pkg_name, ns, names, units, values, index, stock_values, set_pkg_name, max_ns, ns_tot, stock_names, stock_units)
	This routine stores the stocks and does error handling for call_tracer_stocks. More...
subroutine, public	call_tracer_surface_state (sfc_state, h, G, CS)
	This subroutine calls all registered tracer packages to enable them to add to the surface state returned to the coupler. These routines are optional. More...
subroutine, public	tracer_flow_control_end (CS)

Function/Subroutine Documentation

call_tracer_column_fns()

subroutine, public mom_tracer_flow_control::call_tracer_column_fns	(	real, dimension(szi_(g),szj_(g),szk_(gv)), intent(in)	h_old,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(in)	h_new,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(in)	ea,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(in)	eb,
		type(forcing), intent(in)	fluxes,
		real, dimension(szi_(g),szj_(g)), intent(in)	Hml,
		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(thermo_var_ptrs), intent(in)	tv,
		type(optics_type), pointer	optics,
		type(tracer_flow_control_cs), pointer	CS,
		logical, intent(in)	debug,
		real, intent(in), optional	evap_CFL_limit,
		real, intent(in), optional	minimum_forcing_depth
	)

This subroutine calls all registered tracer column physics subroutines.

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 from the layer above during this call will be added [H ~> m or kg m-2].
[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].
[in]	fluxes	A structure containing pointers to any possible forcing fields. Unused fields have NULL ptrs.
[in]	hml	Mixed layer depth [Z ~> m]
[in]	dt	The amount of time covered by this call [T ~> s]
[in]	us	A dimensional unit scaling type
[in]	tv	A structure pointing to various thermodynamic variables.
	optics	The structure containing optical properties.
	cs	The control structure returned by a previous call to call_tracer_register.
[in]	debug	If true calculate checksums
[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 379 of file MOM_tracer_flow_control.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_(GV)), intent(in) :: h_old !< Layer thickness before entrainment
                                                              !! [H ~> m or kg m-2].
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), intent(in) :: h_new !< Layer thickness after entrainment
                                                              !! [H ~> m or kg m-2].
  real, dimension(SZI_(G),SZJ_(G),SZK_(GV)), 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_(GV)), 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
                                                              !! any possible forcing fields.
                                                              !! Unused fields have NULL ptrs.
  real, dimension(SZI_(G),SZJ_(G)),      intent(in) :: Hml    !< Mixed layer depth [Z ~> m]
  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(thermo_var_ptrs),                 intent(in) :: tv     !< A structure pointing to various
                                                              !! thermodynamic variables.
  type(optics_type),                     pointer    :: optics !< The structure containing optical
                                                              !! properties.
  type(tracer_flow_control_CS),          pointer    :: CS     !< The control structure returned by
                                                              !! a previous call to
                                                              !! call_tracer_register.
  logical,                               intent(in) :: debug  !< If true calculate checksums
  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]
 
  if (.not. associated(cs)) call mom_error(fatal, "call_tracer_column_fns: "// &
         "Module must be initialized via call_tracer_register before it is used.")
 
  ! Use the applyTracerBoundaryFluxesInOut to handle surface fluxes
  if (present(evap_cfl_limit) .and. present(minimum_forcing_depth)) then
    ! Add calls to tracer column functions here.
    if (cs%use_USER_tracer_example) &
      call tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                 g, gv, us, cs%USER_tracer_example_CSp)
    if (cs%use_DOME_tracer) &
      call dome_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                      g, gv, us, cs%DOME_tracer_CSp, &
                                      evap_cfl_limit=evap_cfl_limit, &
                                      minimum_forcing_depth=minimum_forcing_depth)
    if (cs%use_ISOMIP_tracer) &
      call isomip_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                        g, gv, us, cs%ISOMIP_tracer_CSp, &
                                        evap_cfl_limit=evap_cfl_limit, &
                                        minimum_forcing_depth=minimum_forcing_depth)
    if (cs%use_RGC_tracer) &
      call rgc_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                        g, gv, us, cs%RGC_tracer_CSp, &
                                        evap_cfl_limit=evap_cfl_limit, &
                                        minimum_forcing_depth=minimum_forcing_depth)
    if (cs%use_ideal_age) &
      call ideal_age_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                           g, gv, us, cs%ideal_age_tracer_CSp, &
                                           evap_cfl_limit=evap_cfl_limit, &
                                           minimum_forcing_depth=minimum_forcing_depth)
    if (cs%use_regional_dyes) &
      call dye_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                     g, gv, us, cs%dye_tracer_CSp, &
                                     evap_cfl_limit=evap_cfl_limit, &
                                     minimum_forcing_depth=minimum_forcing_depth)
    if (cs%use_oil) &
      call oil_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                     g, gv, us, cs%oil_tracer_CSp, tv, &
                                     evap_cfl_limit=evap_cfl_limit, &
                                     minimum_forcing_depth=minimum_forcing_depth)
 
    if (cs%use_advection_test_tracer) &
      call advection_test_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                                g, gv, us, cs%advection_test_tracer_CSp, &
                                                evap_cfl_limit=evap_cfl_limit, &
                                                minimum_forcing_depth=minimum_forcing_depth)
    if (cs%use_OCMIP2_CFC) &
      call ocmip2_cfc_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                     g, gv, us, cs%OCMIP2_CFC_CSp, &
                                     evap_cfl_limit=evap_cfl_limit, &
                                     minimum_forcing_depth=minimum_forcing_depth)
    if (cs%use_MOM_generic_tracer) then
      if (us%QRZ_T_to_W_m2 /= 1.0) call mom_error(fatal, "MOM_generic_tracer_column_physics "//&
            "has not been written to permit dimensionsal rescaling.  Set all 4 of the "//&
            "[QRZT]_RESCALE_POWER parameters to 0.")
      call mom_generic_tracer_column_physics(h_old, h_new, ea, eb, fluxes, hml, us%T_to_s*dt, &
                                             g, gv, cs%MOM_generic_tracer_CSp, tv, optics, &
                                             evap_cfl_limit=evap_cfl_limit, &
                                             minimum_forcing_depth=minimum_forcing_depth)
    endif
    if (cs%use_pseudo_salt_tracer) &
      call pseudo_salt_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                     g, gv, us, cs%pseudo_salt_tracer_CSp, tv, debug, &
                                     evap_cfl_limit=evap_cfl_limit, &
                                     minimum_forcing_depth=minimum_forcing_depth)
    if (cs%use_boundary_impulse_tracer) &
      call boundary_impulse_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                     g, gv, us, cs%boundary_impulse_tracer_CSp, tv, debug, &
                                     evap_cfl_limit=evap_cfl_limit, &
                                     minimum_forcing_depth=minimum_forcing_depth)
    if (cs%use_dyed_obc_tracer) &
      call dyed_obc_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                      g, gv, us, cs%dyed_obc_tracer_CSp, &
                                      evap_cfl_limit=evap_cfl_limit, &
                                      minimum_forcing_depth=minimum_forcing_depth)
 
 
  else ! Apply tracer surface fluxes using ea on the first layer
    if (cs%use_USER_tracer_example) &
      call tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                 g, gv, us, cs%USER_tracer_example_CSp)
    if (cs%use_DOME_tracer) &
      call dome_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                      g, gv, us, cs%DOME_tracer_CSp)
    if (cs%use_ISOMIP_tracer) &
      call isomip_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                      g, gv, us, cs%ISOMIP_tracer_CSp)
    if (cs%use_RGC_tracer) &
      call rgc_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                      g, gv, us, cs%RGC_tracer_CSp)
    if (cs%use_ideal_age) &
      call ideal_age_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                           g, gv, us, cs%ideal_age_tracer_CSp)
    if (cs%use_regional_dyes) &
      call dye_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                           g, gv, us, cs%dye_tracer_CSp)
    if (cs%use_oil) &
      call oil_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                     g, gv, us, cs%oil_tracer_CSp, tv)
    if (cs%use_advection_test_tracer) &
      call advection_test_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                      g, gv, us, cs%advection_test_tracer_CSp)
    if (cs%use_OCMIP2_CFC) &
      call ocmip2_cfc_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                     g, gv, us, cs%OCMIP2_CFC_CSp)
    if (cs%use_MOM_generic_tracer) then
      if (us%QRZ_T_to_W_m2 /= 1.0) call mom_error(fatal, "MOM_generic_tracer_column_physics "//&
            "has not been written to permit dimensionsal rescaling.  Set all 4 of the "//&
            "[QRZT]_RESCALE_POWER parameters to 0.")
      call mom_generic_tracer_column_physics(h_old, h_new, ea, eb, fluxes, hml, us%T_to_s*dt, &
                                     g, gv, cs%MOM_generic_tracer_CSp, tv, optics)
    endif
    if (cs%use_pseudo_salt_tracer) &
      call pseudo_salt_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                     g, gv, us, cs%pseudo_salt_tracer_CSp, tv, debug)
    if (cs%use_boundary_impulse_tracer) &
      call boundary_impulse_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                     g, gv, us, cs%boundary_impulse_tracer_CSp, tv, debug)
    if (cs%use_dyed_obc_tracer) &
      call dyed_obc_tracer_column_physics(h_old, h_new, ea, eb, fluxes, dt, &
                                      g, gv, us, cs%dyed_obc_tracer_CSp)
 
  endif
 
 

call_tracer_flux_init()

subroutine, public mom_tracer_flow_control::call_tracer_flux_init

(

integer, intent(in), optional

verbosity

)

This subroutine carries out a series of calls to initialize the air-sea tracer fluxes, but it does not record the generated indicies, and it may be called before the ocean model has been initialized and may be called on non-ocean PEs. It is not necessary to call this routine for ocean-only runs, because the same calls are made again inside of the routines called by call_tracer_register.

Parameters

[in]

verbosity

A 0-9 integer indicating a level of verbosity.

Definition at line 112 of file MOM_tracer_flow_control.F90.

  integer, optional, intent(in) :: verbosity !< A 0-9 integer indicating a level of verbosity.
 
  type(param_file_type) :: param_file ! A structure to parse for run-time parameters
  character(len=40)  :: mdl = "call_tracer_flux_init"  ! This module's name.
  logical :: use_OCMIP_CFCs, use_MOM_generic_tracer
 
  ! Determine which tracer routines with tracer fluxes are to be called.  Note
  ! that not every tracer package is required to have a flux_init call.
  call get_mom_input(param_file, check_params=.false.)
 
  call get_param(param_file, mdl, "USE_OCMIP2_CFC", use_ocmip_cfcs, &
                 default=.false., do_not_log=.true.)
  call get_param(param_file, mdl, "USE_generic_tracer", use_mom_generic_tracer,&
                 default=.false., do_not_log=.true.)
  call close_param_file(param_file, quiet_close=.true.)
 
  if (use_ocmip_cfcs) call flux_init_ocmip2_cfc(verbosity=verbosity)
  if (use_mom_generic_tracer) then
    call mom_generic_flux_init(verbosity=verbosity)
  endif
 

call_tracer_register()

subroutine, public mom_tracer_flow_control::call_tracer_register	(	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(tracer_flow_control_cs), pointer	CS,
		type(tracer_registry_type), pointer	tr_Reg,
		type(mom_restart_cs), pointer	restart_CS
	)

This subroutine determines which tracer packages are to be used and does the calls to register their tracers to be advected, diffused, and read from restarts.

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 141 of file MOM_tracer_flow_control.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(tracer_flow_control_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.
 
 
  ! This include declares and sets the variable "version".
# include "version_variable.h"
  character(len=40)  :: mdl = "MOM_tracer_flow_control" ! This module's name.
 
  if (associated(cs)) then
    call mom_error(warning, "call_tracer_register called with an associated "// &
                            "control structure.")
    return
  else ; allocate(cs) ; endif
 
  ! Read all relevant parameters and write them to the model log.
  call log_version(param_file, mdl, version, "")
  call get_param(param_file, mdl, "USE_USER_TRACER_EXAMPLE", &
                                cs%use_USER_tracer_example, &
                 "If true, use the USER_tracer_example tracer package.", &
                 default=.false.)
  call get_param(param_file, mdl, "USE_DOME_TRACER", cs%use_DOME_tracer, &
                 "If true, use the DOME_tracer tracer package.", &
                 default=.false.)
  call get_param(param_file, mdl, "USE_ISOMIP_TRACER", cs%use_ISOMIP_tracer, &
                 "If true, use the ISOMIP_tracer tracer package.", &
                 default=.false.)
  call get_param(param_file, mdl, "USE_RGC_TRACER", cs%use_RGC_tracer, &
                 "If true, use the RGC_tracer tracer package.", &
                 default=.false.)
  call get_param(param_file, mdl, "USE_IDEAL_AGE_TRACER", cs%use_ideal_age, &
                 "If true, use the ideal_age_example tracer package.", &
                 default=.false.)
  call get_param(param_file, mdl, "USE_REGIONAL_DYES", cs%use_regional_dyes, &
                 "If true, use the regional_dyes tracer package.", &
                 default=.false.)
  call get_param(param_file, mdl, "USE_OIL_TRACER", cs%use_oil, &
                 "If true, use the oil_tracer tracer package.", &
                 default=.false.)
  call get_param(param_file, mdl, "USE_ADVECTION_TEST_TRACER", cs%use_advection_test_tracer, &
                 "If true, use the advection_test_tracer tracer package.", &
                 default=.false.)
  call get_param(param_file, mdl, "USE_OCMIP2_CFC", cs%use_OCMIP2_CFC, &
                 "If true, use the MOM_OCMIP2_CFC tracer package.", &
                 default=.false.)
  call get_param(param_file, mdl, "USE_generic_tracer", cs%use_MOM_generic_tracer, &
                 "If true and _USE_GENERIC_TRACER is defined as a "//&
                 "preprocessor macro, use the MOM_generic_tracer packages.", &
                 default=.false.)
  call get_param(param_file, mdl, "USE_PSEUDO_SALT_TRACER", cs%use_pseudo_salt_tracer, &
                 "If true, use the pseudo salt tracer, typically run as a diagnostic.", &
                 default=.false.)
  call get_param(param_file, mdl, "USE_BOUNDARY_IMPULSE_TRACER", cs%use_boundary_impulse_tracer, &
                 "If true, use the boundary impulse tracer.", &
                 default=.false.)
  call get_param(param_file, mdl, "USE_DYED_OBC_TRACER", cs%use_dyed_obc_tracer, &
                 "If true, use the dyed_obc_tracer tracer package.", &
                 default=.false.)
 
!    Add other user-provided calls to register tracers for restarting here. Each
!  tracer package registration call returns a logical false if it cannot be run
!  for some reason.  This then overrides the run-time selection from above.
  if (cs%use_USER_tracer_example) cs%use_USER_tracer_example = &
    user_register_tracer_example(hi, gv, param_file, cs%USER_tracer_example_CSp, &
                                 tr_reg, restart_cs)
  if (cs%use_DOME_tracer) cs%use_DOME_tracer = &
    register_dome_tracer(hi, gv, param_file, cs%DOME_tracer_CSp, &
                         tr_reg, restart_cs)
  if (cs%use_ISOMIP_tracer) cs%use_ISOMIP_tracer = &
    register_isomip_tracer(hi, gv, param_file, cs%ISOMIP_tracer_CSp, &
                           tr_reg, restart_cs)
  if (cs%use_RGC_tracer) cs%use_RGC_tracer = &
    register_rgc_tracer(hi, gv, param_file, cs%RGC_tracer_CSp, &
                           tr_reg, restart_cs)
  if (cs%use_ideal_age) cs%use_ideal_age = &
    register_ideal_age_tracer(hi, gv, param_file,  cs%ideal_age_tracer_CSp, &
                              tr_reg, restart_cs)
  if (cs%use_regional_dyes) cs%use_regional_dyes = &
    register_dye_tracer(hi, gv, us, param_file,  cs%dye_tracer_CSp, &
                        tr_reg, restart_cs)
  if (cs%use_oil) cs%use_oil = &
    register_oil_tracer(hi, gv, us, param_file,  cs%oil_tracer_CSp, &
                        tr_reg, restart_cs)
  if (cs%use_advection_test_tracer) cs%use_advection_test_tracer = &
    register_advection_test_tracer(hi, gv, param_file, cs%advection_test_tracer_CSp, &
                                   tr_reg, restart_cs)
  if (cs%use_OCMIP2_CFC) cs%use_OCMIP2_CFC = &
    register_ocmip2_cfc(hi, gv, param_file,  cs%OCMIP2_CFC_CSp, &
                        tr_reg, restart_cs)
  if (cs%use_MOM_generic_tracer) cs%use_MOM_generic_tracer = &
    register_mom_generic_tracer(hi, gv, param_file,  cs%MOM_generic_tracer_CSp, &
                                tr_reg, restart_cs)
  if (cs%use_pseudo_salt_tracer) cs%use_pseudo_salt_tracer = &
    register_pseudo_salt_tracer(hi, gv, param_file,  cs%pseudo_salt_tracer_CSp, &
                                tr_reg, restart_cs)
  if (cs%use_boundary_impulse_tracer) cs%use_boundary_impulse_tracer = &
    register_boundary_impulse_tracer(hi, gv, param_file,  cs%boundary_impulse_tracer_CSp, &
                                     tr_reg, restart_cs)
  if (cs%use_dyed_obc_tracer) cs%use_dyed_obc_tracer = &
    register_dyed_obc_tracer(hi, gv, param_file, cs%dyed_obc_tracer_CSp, &
                             tr_reg, restart_cs)
 
 

call_tracer_set_forcing()

subroutine, public mom_tracer_flow_control::call_tracer_set_forcing	(	type(surface), intent(inout)	sfc_state,
		type(forcing), intent(inout)	fluxes,
		type(time_type), intent(in)	day_start,
		type(time_type), intent(in)	day_interval,
		type(ocean_grid_type), intent(in)	G,
		type(tracer_flow_control_cs), pointer	CS
	)

This subroutine calls the individual tracer modules' subroutines to specify or read quantities related to their surface forcing.

Parameters

[in,out]	sfc_state	A structure containing fields that describe the surface state of the ocean.
[in,out]	fluxes	A structure containing pointers to any possible forcing fields. Unused fields have NULL ptrs.
[in]	day_start	Start time of the fluxes.
[in]	day_interval	Length of time over which these fluxes will be applied.
[in]	g	The ocean's grid structure.
	cs	The control structure returned by a previous call to call_tracer_register.

Definition at line 355 of file MOM_tracer_flow_control.F90.

 
  type(surface),                intent(inout) :: sfc_state !< A structure containing fields that
                                                           !! describe the surface state of the
                                                           !! ocean.
  type(forcing),                intent(inout) :: fluxes    !< A structure containing pointers to any
                                                           !! possible forcing fields. Unused fields
                                                           !! have NULL ptrs.
  type(time_type),              intent(in)    :: day_start !< Start time of the fluxes.
  type(time_type),              intent(in)    :: day_interval !< Length of time over which these
                                                           !! fluxes will be applied.
  type(ocean_grid_type),        intent(in)    :: G         !< The ocean's grid structure.
  type(tracer_flow_control_CS), pointer       :: CS        !< The control structure returned by a
                                                           !! previous call to call_tracer_register.
 
  if (.not. associated(cs)) call mom_error(fatal, "call_tracer_set_forcing"// &
         "Module must be initialized via call_tracer_register before it is used.")
!  if (CS%use_ideal_age) &
!    call ideal_age_tracer_set_forcing(sfc_state, fluxes, day_start, day_interval, &
!                                      G, CS%ideal_age_tracer_CSp)
 

call_tracer_stocks()

subroutine, public mom_tracer_flow_control::call_tracer_stocks	(	real, dimension(szi_(g),szj_(g),szk_(gv)), intent(in)	h,
		real, dimension(:), intent(out)	stock_values,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(tracer_flow_control_cs), pointer	CS,
		character(len=*), dimension(:), intent(out), optional	stock_names,
		character(len=*), dimension(:), intent(out), optional	stock_units,
		integer, intent(out), optional	num_stocks,
		integer, intent(in), optional	stock_index,
		logical, dimension(:), intent(inout), optional	got_min_max,
		real, dimension(:), intent(out), optional	global_min,
		real, dimension(:), intent(out), optional	global_max,
		real, dimension(:), intent(out), optional	xgmin,
		real, dimension(:), intent(out), optional	ygmin,
		real, dimension(:), intent(out), optional	zgmin,
		real, dimension(:), intent(out), optional	xgmax,
		real, dimension(:), intent(out), optional	ygmax,
		real, dimension(:), intent(out), optional	zgmax
	)

This subroutine calls all registered tracer packages to enable them to add to the surface state returned to the coupler. These routines are optional.

Parameters

[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]
[out]	stock_values	The integrated amounts of a tracer on the current PE, usually in kg x concentration [kg conc].
	cs	The control structure returned by a previous call to call_tracer_register.
[out]	stock_names	Diagnostic names to use for each stock.
[out]	stock_units	Units to use in the metadata for each stock.
[out]	num_stocks	The number of tracer stocks being returned.
[in]	stock_index	The integer stock index from stocks_constants_mod of the stock to be returned. If this is present and greater than 0, only a single stock can be returned.
[in,out]	got_min_max	Indicates whether the global min and
[out]	global_min	The global minimum of each tracer
[out]	global_max	The global maximum of each tracer
[out]	xgmin	The x-position of the global minimum
[out]	ygmin	The y-position of the global minimum
[out]	zgmin	The z-position of the global minimum
[out]	xgmax	The x-position of the global maximum
[out]	ygmax	The y-position of the global maximum
[out]	zgmax	The z-position of the global maximum

Definition at line 542 of file MOM_tracer_flow_control.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_(GV)),    &
                                  intent(in)  :: h           !< Layer thicknesses [H ~> m or kg m-2]
  real, dimension(:),             intent(out) :: stock_values !< The integrated amounts of a tracer
                             !! on the current PE, usually in kg x concentration [kg conc].
  type(tracer_flow_control_CS),   pointer     :: CS          !< The control structure returned by a
                                                             !! previous call to
                                                             !! call_tracer_register.
  character(len=*), dimension(:), &
                        optional, intent(out) :: stock_names !< Diagnostic names to use for each stock.
  character(len=*), dimension(:), &
                        optional, intent(out) :: stock_units !< Units to use in the metadata for each stock.
  integer,              optional, intent(out) :: num_stocks  !< The number of tracer stocks being returned.
  integer,              optional, intent(in)  :: stock_index !< The integer stock index from
                             !! stocks_constants_mod of the stock to be returned.  If this is
                             !! present and greater than 0, only a single stock can be returned.
  logical, dimension(:), &
                      optional, intent(inout) :: got_min_max !< Indicates whether the global min and
                                                             !! max are found for each tracer
  real, dimension(:), optional, intent(out)   :: global_min  !< The global minimum of each tracer
  real, dimension(:), optional, intent(out)   :: global_max  !< The global maximum of each tracer
  real, dimension(:), optional, intent(out)   :: xgmin       !< The x-position of the global minimum
  real, dimension(:), optional, intent(out)   :: ygmin       !< The y-position of the global minimum
  real, dimension(:), optional, intent(out)   :: zgmin       !< The z-position of the global minimum
  real, dimension(:), optional, intent(out)   :: xgmax       !< The x-position of the global maximum
  real, dimension(:), optional, intent(out)   :: ygmax       !< The y-position of the global maximum
  real, dimension(:), optional, intent(out)   :: zgmax       !< The z-position of the global maximum
 
  ! Local variables
  character(len=200), dimension(MAX_FIELDS_) :: names, units
  character(len=200) :: set_pkg_name
  real, dimension(MAX_FIELDS_) :: values
  integer :: max_ns, ns_tot, ns, index, pkg, max_pkgs, nn
 
  if (.not. associated(cs)) call mom_error(fatal, "call_tracer_stocks: "// &
       "Module must be initialized via call_tracer_register before it is used.")
 
  index = -1 ; if (present(stock_index)) index = stock_index
  ns_tot = 0
  max_ns = size(stock_values)
  if (present(stock_names)) max_ns = min(max_ns,size(stock_names))
  if (present(stock_units)) max_ns = min(max_ns,size(stock_units))
 
!  Add other user-provided calls here.
  if (cs%use_USER_tracer_example) then
    ns = user_tracer_stock(h, values, g, gv, cs%USER_tracer_example_CSp, &
                           names, units, stock_index)
    call store_stocks("tracer_example", ns, names, units, values, index, stock_values, &
                       set_pkg_name, max_ns, ns_tot, stock_names, stock_units)
  endif
! if (CS%use_DOME_tracer) then
!   ns = DOME_tracer_stock(h, values, G, GV, CS%DOME_tracer_CSp, &
!                          names, units, stock_index)
!   call store_stocks("DOME_tracer", ns, names, units, values, index, stock_values, &
!                      set_pkg_name, max_ns, ns_tot, stock_names, stock_units)
! endif
  if (cs%use_ideal_age) then
    ns = ideal_age_stock(h, values, g, gv, cs%ideal_age_tracer_CSp, &
                         names, units, stock_index)
    call store_stocks("ideal_age_example", ns, names, units, values, index, &
           stock_values, set_pkg_name, max_ns, ns_tot, stock_names, stock_units)
  endif
  if (cs%use_regional_dyes) then
    ns = dye_stock(h, values, g, gv, cs%dye_tracer_CSp, &
                         names, units, stock_index)
    call store_stocks("regional_dyes", ns, names, units, values, index, &
           stock_values, set_pkg_name, max_ns, ns_tot, stock_names, stock_units)
  endif
  if (cs%use_oil) then
    ns = oil_stock(h, values, g, gv, cs%oil_tracer_CSp, &
                         names, units, stock_index)
    call store_stocks("oil_tracer", ns, names, units, values, index, &
           stock_values, set_pkg_name, max_ns, ns_tot, stock_names, stock_units)
  endif
  if (cs%use_OCMIP2_CFC) then
    ns = ocmip2_cfc_stock(h, values, g, gv, cs%OCMIP2_CFC_CSp, names, units, stock_index)
    call store_stocks("MOM_OCMIP2_CFC", ns, names, units, values, index, stock_values, &
                       set_pkg_name, max_ns, ns_tot, stock_names, stock_units)
  endif
 
  if (cs%use_advection_test_tracer) then
    ns = advection_test_stock( h, values, g, gv, cs%advection_test_tracer_CSp, &
                         names, units, stock_index )
    call store_stocks("advection_test_tracer", ns, names, units, values, index, &
           stock_values, set_pkg_name, max_ns, ns_tot, stock_names, stock_units)
  endif
 
  if (cs%use_MOM_generic_tracer) then
    ns = mom_generic_tracer_stock(h, values, g, gv, cs%MOM_generic_tracer_CSp, &
                                   names, units, stock_index)
    call store_stocks("MOM_generic_tracer", ns, names, units, values, index, stock_values, &
                       set_pkg_name, max_ns, ns_tot, stock_names, stock_units)
    nn=ns_tot-ns+1
    nn=mom_generic_tracer_min_max(nn, got_min_max, global_min,  global_max, &
                                  xgmin, ygmin, zgmin, xgmax, ygmax, zgmax ,&
                                  g, cs%MOM_generic_tracer_CSp,names, units)
 
  endif
  if (cs%use_pseudo_salt_tracer) then
    ns = pseudo_salt_stock(h, values, g, gv, cs%pseudo_salt_tracer_CSp, &
                         names, units, stock_index)
    call store_stocks("pseudo_salt_tracer", ns, names, units, values, index, &
           stock_values, set_pkg_name, max_ns, ns_tot, stock_names, stock_units)
  endif
 
  if (cs%use_boundary_impulse_tracer) then
    ns = boundary_impulse_stock(h, values, g, gv, cs%boundary_impulse_tracer_CSp, &
                         names, units, stock_index)
    call store_stocks("boundary_impulse_tracer", ns, names, units, values, index, &
           stock_values, set_pkg_name, max_ns, ns_tot, stock_names, stock_units)
  endif
 
  if (ns_tot == 0) stock_values(1) = 0.0
 
  if (present(num_stocks)) num_stocks = ns_tot
 

call_tracer_surface_state()

subroutine, public mom_tracer_flow_control::call_tracer_surface_state	(	type(surface), intent(inout)	sfc_state,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	h,
		type(ocean_grid_type), intent(in)	G,
		type(tracer_flow_control_cs), pointer	CS
	)

This subroutine calls all registered tracer packages to enable them to add to the surface state returned to the coupler. These routines are optional.

Parameters

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

Definition at line 725 of file MOM_tracer_flow_control.F90.

  type(surface),                intent(inout) :: sfc_state !< A structure containing fields that
                                                       !! describe the surface state of the ocean.
  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]
  type(tracer_flow_control_CS), pointer       :: CS    !< The control structure returned by a
                                                       !! previous call to call_tracer_register.
 
  if (.not. associated(cs)) call mom_error(fatal, "call_tracer_surface_state: "// &
         "Module must be initialized via call_tracer_register before it is used.")
 
!  Add other user-provided calls here.
  if (cs%use_USER_tracer_example) &
    call user_tracer_surface_state(sfc_state, h, g, cs%USER_tracer_example_CSp)
  if (cs%use_DOME_tracer) &
    call dome_tracer_surface_state(sfc_state, h, g, cs%DOME_tracer_CSp)
  if (cs%use_ISOMIP_tracer) &
    call isomip_tracer_surface_state(sfc_state, h, g, cs%ISOMIP_tracer_CSp)
  if (cs%use_ideal_age) &
    call ideal_age_tracer_surface_state(sfc_state, h, g, cs%ideal_age_tracer_CSp)
  if (cs%use_regional_dyes) &
    call dye_tracer_surface_state(sfc_state, h, g, cs%dye_tracer_CSp)
  if (cs%use_oil) &
    call oil_tracer_surface_state(sfc_state, h, g, cs%oil_tracer_CSp)
  if (cs%use_advection_test_tracer) &
    call advection_test_tracer_surface_state(sfc_state, h, g, cs%advection_test_tracer_CSp)
  if (cs%use_OCMIP2_CFC) &
    call ocmip2_cfc_surface_state(sfc_state, h, g, cs%OCMIP2_CFC_CSp)
  if (cs%use_MOM_generic_tracer) &
    call mom_generic_tracer_surface_state(sfc_state, h, g, cs%MOM_generic_tracer_CSp)
 

get_chl_from_model()

subroutine, public mom_tracer_flow_control::get_chl_from_model	(	real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(out)	Chl_array,
		type(ocean_grid_type), intent(in)	G,
		type(tracer_flow_control_cs), pointer	CS
	)

This subroutine extracts the chlorophyll concentrations from the model state, if possible.

Parameters

[in]	g	The ocean's grid structure.
[out]	chl_array	The array in which to store the model's
	cs	The control structure returned by a previous call to call_tracer_register.

Definition at line 335 of file MOM_tracer_flow_control.F90.

  type(ocean_grid_type),        intent(in)  :: G         !< The ocean's grid structure.
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                                intent(out) :: Chl_array !< The array in which to store the model's
                                                         !! Chlorophyll-A concentrations in mg m-3.
  type(tracer_flow_control_CS), pointer     :: CS        !< The control structure returned by a
                                                         !! previous call to call_tracer_register.
 
  if (cs%use_MOM_generic_tracer) then
    call mom_generic_tracer_get('chl', 'field', chl_array, cs%MOM_generic_tracer_CSp)
  else
    call mom_error(fatal, "get_chl_from_model was called in a configuration "// &
             "that is unable to provide a sensible model-based value.\n"// &
             "CS%use_MOM_generic_tracer is false and no other viable options are on.")
  endif
 

store_stocks()

subroutine mom_tracer_flow_control::store_stocks ( character(len=*), intent(in)  pkg_name, integer, intent(in)  ns, character(len=*), dimension(:), intent(in)  names, character(len=*), dimension(:), intent(in)  units, real, dimension(:), intent(in)  values, integer, intent(in)  index, real, dimension(:), intent(inout)  stock_values, character(len=*), intent(inout)  set_pkg_name, integer, intent(in)  max_ns, integer, intent(inout)  ns_tot, character(len=*), dimension(:), intent(inout), optional  stock_names, character(len=*), dimension(:), intent(inout), optional  stock_units  )

private

This routine stores the stocks and does error handling for call_tracer_stocks.

Parameters

[in]	pkg_name	The tracer package name
[in]	ns	The number of stocks associated with this tracer package
[in]	names	Diagnostic names to use for each stock.
[in]	units	Units to use in the metadata for each stock.
[in]	values	The values of the tracer stocks
[in]	index	The integer stock index from stocks_constants_mod of the stock to be returned. If this is present and greater than 0, only a single stock can be returned.
[in,out]	stock_values	The master list of stock values
[in,out]	set_pkg_name	The name of the last tracer package whose stocks were stored for a specific index. This is used to trigger an error if there are redundant stocks.
[in]	max_ns	The maximum size of the master stock list
[in,out]	ns_tot	The total number of stocks in the master list
[in,out]	stock_names	Diagnostic names to use for each stock in the master list
[in,out]	stock_units	Units to use in the metadata for each stock in the master list

Definition at line 665 of file MOM_tracer_flow_control.F90.

  character(len=*),   intent(in)    :: pkg_name !< The tracer package name
  integer,            intent(in)    :: ns      !< The number of stocks associated with this tracer package
  character(len=*), dimension(:), &
                      intent(in)    :: names   !< Diagnostic names to use for each stock.
  character(len=*), dimension(:), &
                      intent(in)    :: units   !< Units to use in the metadata for each stock.
  real, dimension(:), intent(in)    :: values  !< The values of the tracer stocks
  integer,            intent(in)    :: index   !< The integer stock index from
                             !! stocks_constants_mod of the stock to be returned.  If this is
                             !! present and greater than 0, only a single stock can be returned.
  real, dimension(:), intent(inout) :: stock_values !< The master list of stock values
  character(len=*),   intent(inout) :: set_pkg_name !< The name of the last tracer package whose
                                               !! stocks were stored for a specific index.  This is
                                               !! used to trigger an error if there are redundant stocks.
  integer,            intent(in)    :: max_ns  !< The maximum size of the master stock list
  integer,            intent(inout) :: ns_tot  !< The total number of stocks in the master list
  character(len=*), dimension(:), &
            optional, intent(inout) :: stock_names !< Diagnostic names to use for each stock in the master list
  character(len=*), dimension(:), &
            optional, intent(inout) :: stock_units !< Units to use in the metadata for each stock in the master list
 
! This routine stores the stocks and does error handling for call_tracer_stocks.
  character(len=16) :: ind_text, ns_text, max_text
  integer :: n
 
  if ((index > 0) .and. (ns > 0)) then
    write(ind_text,'(i8)') index
    if (ns > 1) then
      call mom_error(fatal,"Tracer package "//trim(pkg_name)//&
          " is not permitted to return more than one value when queried"//&
          " for specific stock index "//trim(adjustl(ind_text))//".")
    elseif (ns+ns_tot > 1) then
      call mom_error(fatal,"Tracer packages "//trim(pkg_name)//" and "//&
          trim(set_pkg_name)//" both attempted to set values for"//&
          " specific stock index "//trim(adjustl(ind_text))//".")
    else
      set_pkg_name = pkg_name
    endif
  endif
 
  if (ns_tot+ns > max_ns) then
    write(ns_text,'(i8)') ns_tot+ns ; write(max_text,'(i8)') max_ns
    call mom_error(fatal,"Attempted to return more tracer stock values (at least "//&
      trim(adjustl(ns_text))//") than the size "//trim(adjustl(max_text))//&
      "of the smallest value, name, or units array.")
  endif
 
  do n=1,ns
    stock_values(ns_tot+n) = values(n)
    if (present(stock_names)) stock_names(ns_tot+n) = names(n)
    if (present(stock_units)) stock_units(ns_tot+n) = units(n)
  enddo
  ns_tot = ns_tot + ns
 

tracer_flow_control_end()

subroutine, public mom_tracer_flow_control::tracer_flow_control_end

(

type(tracer_flow_control_cs), pointer

CS

)

Parameters

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

Definition at line 759 of file MOM_tracer_flow_control.F90.

  type(tracer_flow_control_CS), pointer :: CS    !< The control structure returned by a
                                                 !! previous call to call_tracer_register.
 
  if (cs%use_USER_tracer_example) &
    call user_tracer_example_end(cs%USER_tracer_example_CSp)
  if (cs%use_DOME_tracer) call dome_tracer_end(cs%DOME_tracer_CSp)
  if (cs%use_ISOMIP_tracer) call isomip_tracer_end(cs%ISOMIP_tracer_CSp)
  if (cs%use_RGC_tracer) call rgc_tracer_end(cs%RGC_tracer_CSp)
  if (cs%use_ideal_age) call ideal_age_example_end(cs%ideal_age_tracer_CSp)
  if (cs%use_regional_dyes) call regional_dyes_end(cs%dye_tracer_CSp)
  if (cs%use_oil) call oil_tracer_end(cs%oil_tracer_CSp)
  if (cs%use_advection_test_tracer) call advection_test_tracer_end(cs%advection_test_tracer_CSp)
  if (cs%use_OCMIP2_CFC) call ocmip2_cfc_end(cs%OCMIP2_CFC_CSp)
  if (cs%use_MOM_generic_tracer) call end_mom_generic_tracer(cs%MOM_generic_tracer_CSp)
  if (cs%use_pseudo_salt_tracer) call pseudo_salt_tracer_end(cs%pseudo_salt_tracer_CSp)
  if (cs%use_boundary_impulse_tracer) call boundary_impulse_tracer_end(cs%boundary_impulse_tracer_CSp)
  if (cs%use_dyed_obc_tracer) call dyed_obc_tracer_end(cs%dyed_obc_tracer_CSp)
 
  if (associated(cs)) deallocate(cs)

tracer_flow_control_init()

subroutine, public mom_tracer_flow_control::tracer_flow_control_init	(	logical, intent(in)	restart,
		type(time_type), intent(in), target	day,
		type(ocean_grid_type), intent(inout)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(unit_scale_type), intent(in)	US,
		real, dimension(szi_(g),szj_(g),szk_(gv)), intent(in)	h,
		type(param_file_type), intent(in)	param_file,
		type(diag_ctrl), intent(in), target	diag,
		type(ocean_obc_type), pointer	OBC,
		type(tracer_flow_control_cs), pointer	CS,
		type(sponge_cs), pointer	sponge_CSp,
		type(ale_sponge_cs), pointer	ALE_sponge_CSp,
		type(thermo_var_ptrs), intent(in)	tv
	)

This subroutine calls all registered tracer initialization subroutines.

Parameters

[in]	restart	1 if the fields have already been read from a restart file.
[in]	day	Time of the start of the run.
[in,out]	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]	param_file	A structure to parse for run-time parameters
[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 call_tracer_register.
	sponge_csp	A pointer to the control structure for the sponges, if they are in use. Otherwise this may be unassociated.
	ale_sponge_csp	A pointer to the control structure for the ALE sponges, if they are in use. Otherwise this may be unassociated.
[in]	tv	A structure pointing to various thermodynamic variables

Definition at line 258 of file MOM_tracer_flow_control.F90.

  logical,                               intent(in)    :: restart !< 1 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(inout) :: 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_(GV)), &
                                         intent(in)    :: h       !< Layer thicknesses [H ~> m or kg m-2]
  type(param_file_type),                 intent(in)    :: param_file !< A structure to parse for
                                                                  !! run-time parameters
  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(tracer_flow_control_CS),          pointer       :: CS      !< The control structure returned
                                                                  !! by a previous call to
                                                                  !! call_tracer_register.
  type(sponge_CS),                       pointer       :: sponge_CSp     !< A pointer to the control
                                               !! structure for the sponges, if they are in use.
                                               !! Otherwise this may be unassociated.
  type(ALE_sponge_CS),                   pointer       :: ALE_sponge_CSp !< A pointer to the control
                                               !! structure for the ALE sponges, if they are in use.
                                               !! Otherwise this may be unassociated.
  type(thermo_var_ptrs),                 intent(in)    :: tv      !< A structure pointing to various
                                                                  !! thermodynamic variables
 
  if (.not. associated(cs)) call mom_error(fatal, "tracer_flow_control_init: "// &
         "Module must be initialized via call_tracer_register before it is used.")
 
!  Add other user-provided calls here.
  if (cs%use_USER_tracer_example) &
    call user_initialize_tracer(restart, day, g, gv, h, diag, obc, cs%USER_tracer_example_CSp, &
                                sponge_csp)
  if (cs%use_DOME_tracer) &
    call initialize_dome_tracer(restart, day, g, gv, us, h, diag, obc, cs%DOME_tracer_CSp, &
                                sponge_csp, param_file)
  if (cs%use_ISOMIP_tracer) &
    call initialize_isomip_tracer(restart, day, g, gv, h, diag, obc, cs%ISOMIP_tracer_CSp, &
                                ale_sponge_csp)
  if (cs%use_RGC_tracer) &
    call initialize_rgc_tracer(restart, day, g, gv, h, diag, obc, &
                  cs%RGC_tracer_CSp, sponge_csp, ale_sponge_csp)
  if (cs%use_ideal_age) &
    call initialize_ideal_age_tracer(restart, day, g, gv, us, h, diag, obc, cs%ideal_age_tracer_CSp, &
                                     sponge_csp)
  if (cs%use_regional_dyes) &
    call initialize_dye_tracer(restart, day, g, gv, h, diag, obc, cs%dye_tracer_CSp, &
                                     sponge_csp)
  if (cs%use_oil) &
    call initialize_oil_tracer(restart, day, g, gv, us, h, diag, obc, cs%oil_tracer_CSp, &
                                     sponge_csp)
  if (cs%use_advection_test_tracer) &
    call initialize_advection_test_tracer(restart, day, g, gv, h, diag, obc, cs%advection_test_tracer_CSp, &
                                sponge_csp)
  if (cs%use_OCMIP2_CFC) &
    call initialize_ocmip2_cfc(restart, day, g, gv, us, h, diag, obc, cs%OCMIP2_CFC_CSp, &
                                sponge_csp)
  if (cs%use_MOM_generic_tracer) &
    call initialize_mom_generic_tracer(restart, day, g, gv, us, h, param_file, diag, obc, &
        cs%MOM_generic_tracer_CSp, sponge_csp, ale_sponge_csp)
  if (cs%use_pseudo_salt_tracer) &
    call initialize_pseudo_salt_tracer(restart, day, g, gv, h, diag, obc, cs%pseudo_salt_tracer_CSp, &
                                sponge_csp, tv)
  if (cs%use_boundary_impulse_tracer) &
    call initialize_boundary_impulse_tracer(restart, day, g, gv, h, diag, obc, cs%boundary_impulse_tracer_CSp, &
                                sponge_csp, tv)
  if (cs%use_dyed_obc_tracer) &
    call initialize_dyed_obc_tracer(restart, day, g, gv, h, diag, obc, cs%dyed_obc_tracer_CSp)