Detailed Description

This module contains the tracer_registry_type and the subroutines that handle registration of tracers and related subroutines. The primary subroutine, register_tracer, is called to indicate the tracers advected and diffused.

Data Types
type	tracer_registry_type
	Type to carry basic tracer information. More...

type	tracer_type
	The tracer type. More...

Functions/Subroutines
subroutine, public	register_tracer (tr1, tr_desc, param_file, HI, GV, Reg, tr_desc_ptr, ad_x, ad_y, df_x, df_y, OBC_inflow, OBC_in_u, OBC_in_v, ad_2d_x, ad_2d_y, df_2d_x, df_2d_y, advection_xy)
	This subroutine registers a tracer to be advected and laterally diffused. More...

subroutine, public	lock_tracer_registry (Reg)
	This subroutine locks the tracer registry to prevent the addition of more tracers. After locked=.true., can then register common diagnostics. More...

subroutine, public	add_tracer_obc_values (name, Reg, OBC_inflow, OBC_in_u, OBC_in_v)
	This subroutine adds open boundary condition concentrations for a tracer that has previously been registered by a call to register_tracer. More...

subroutine, public	add_tracer_diagnostics (name, Reg, ad_x, ad_y, df_x, df_y, ad_2d_x, ad_2d_y, df_2d_x, df_2d_y, advection_xy)
	This subroutine adds diagnostic arrays for a tracer that has previously been registered by a call to register_tracer. More...

subroutine, public	mom_tracer_chksum (mesg, Tr, ntr, G)
	This subroutine writes out chksums for tracers. More...

subroutine, public	mom_tracer_chkinv (mesg, G, h, Tr, ntr)
	Calculates and prints the global inventory of all tracers in the registry. More...

subroutine, public	tracer_registry_init (param_file, Reg)
	This routine include declares and sets the variable "version". More...

subroutine, public	tracer_registry_end (Reg)
	This routine closes the tracer registry module. More...

Function/Subroutine Documentation

◆ add_tracer_diagnostics()

subroutine, public mom_tracer_registry::add_tracer_diagnostics	(	character(len=*), intent(in)	name,
		type(tracer_registry_type), pointer	Reg,
		real, dimension(:,:,:), optional, pointer	ad_x,
		real, dimension(:,:,:), optional, pointer	ad_y,
		real, dimension(:,:,:), optional, pointer	df_x,
		real, dimension(:,:,:), optional, pointer	df_y,
		real, dimension(:,:), optional, pointer	ad_2d_x,
		real, dimension(:,:), optional, pointer	ad_2d_y,
		real, dimension(:,:), optional, pointer	df_2d_x,
		real, dimension(:,:), optional, pointer	df_2d_y,
		real, dimension(:,:,:), optional, pointer	advection_xy
	)

This subroutine adds diagnostic arrays for a tracer that has previously been registered by a call to register_tracer.

Parameters

[in]	name	name of the tracer for which the diagnostic points
	reg	pointer to the tracer registry
	ad_x	diagnostic x-advective flux (CONC m3/s or CONC*kg/s)
	ad_y	diagnostic y-advective flux (CONC m3/s or CONC*kg/s)
	df_x	diagnostic x-diffusive flux (CONC m3/s or CONC*kg/s)
	df_y	diagnostic y-diffusive flux (CONC m3/s or CONC*kg/s)
	ad_2d_x	vert sum of diagnostic x-advect flux (CONC m3/s or CONC*kg/s)
	ad_2d_y	vert sum of diagnostic y-advect flux (CONC m3/s or CONC*kg/s)
	df_2d_x	vert sum of diagnostic x-diffuse flux (CONC m3/s or CONC*kg/s)
	df_2d_y	vert sum of diagnostic y-diffuse flux (CONC m3/s or CONC*kg/s)
	advection_xy	convergence of lateral advective tracer fluxes

Definition at line 210 of file MOM_tracer_registry.F90.

References mom_error_handler::mom_error().

Referenced by advection_test_tracer::initialize_advection_test_tracer(), boundary_impulse_tracer::initialize_boundary_impulse_tracer(), dome_tracer::initialize_dome_tracer(), regional_dyes::initialize_dye_tracer(), ideal_age_example::initialize_ideal_age_tracer(), isomip_tracer::initialize_isomip_tracer(), mom_ocmip2_cfc::initialize_ocmip2_cfc(), oil_tracer::initialize_oil_tracer(), pseudo_salt_tracer::initialize_pseudo_salt_tracer(), and user_tracer_example::user_initialize_tracer().

   character(len=*), intent(in)              :: name         !< name of the tracer for which the diagnostic points
   type(tracer_registry_type), pointer       :: reg          !< pointer to the tracer registry
   real, dimension(:,:,:), pointer, optional :: ad_x         !< diagnostic x-advective flux (CONC m3/s or CONC*kg/s)
   real, dimension(:,:,:), pointer, optional :: ad_y         !< diagnostic y-advective flux (CONC m3/s or CONC*kg/s)
   real, dimension(:,:,:), pointer, optional :: df_x         !< diagnostic x-diffusive flux (CONC m3/s or CONC*kg/s)
   real, dimension(:,:,:), pointer, optional :: df_y         !< diagnostic y-diffusive flux (CONC m3/s or CONC*kg/s)
   real, dimension(:,:),   pointer, optional :: ad_2d_x      !< vert sum of diagnostic x-advect flux (CONC m3/s or CONC*kg/s)
   real, dimension(:,:),   pointer, optional :: ad_2d_y      !< vert sum of diagnostic y-advect flux (CONC m3/s or CONC*kg/s)
   real, dimension(:,:),   pointer, optional :: df_2d_x      !< vert sum of diagnostic x-diffuse flux (CONC m3/s or CONC*kg/s)
   real, dimension(:,:),   pointer, optional :: df_2d_y      !< vert sum of diagnostic y-diffuse flux (CONC m3/s or CONC*kg/s)
 
   real, dimension(:,:,:), pointer, optional :: advection_xy !< convergence of lateral advective tracer fluxes
 
   integer :: m
 
   if (.not. associated(reg)) call mom_error(fatal, "add_tracer_diagnostics: "// &
        "register_tracer must be called before add_tracer_diagnostics")
 
   do m=1,reg%ntr ; if (reg%Tr(m)%name == trim(name)) exit ; enddo
 
   if (m <= reg%ntr) then
     if (present(ad_x)) then ; if (associated(ad_x)) reg%Tr(m)%ad_x => ad_x ; endif
     if (present(ad_y)) then ; if (associated(ad_y)) reg%Tr(m)%ad_y => ad_y ; endif
     if (present(df_x)) then ; if (associated(df_x)) reg%Tr(m)%df_x => df_x ; endif
     if (present(df_y)) then ; if (associated(df_y)) reg%Tr(m)%df_y => df_y ; endif
 
     if (present(ad_2d_x)) then ; if (associated(ad_2d_x)) reg%Tr(m)%ad2d_x => ad_2d_x ; endif
     if (present(ad_2d_y)) then ; if (associated(ad_2d_y)) reg%Tr(m)%ad2d_y => ad_2d_y ; endif
     if (present(df_2d_x)) then ; if (associated(df_2d_x)) reg%Tr(m)%df2d_x => df_2d_x ; endif
     if (present(df_2d_y)) then ; if (associated(df_2d_y)) reg%Tr(m)%df2d_y => df_2d_y ; endif
 
     if (present(advection_xy)) then ; if (associated(advection_xy)) reg%Tr(m)%advection_xy => advection_xy ; endif
 
   else
 
     call mom_error(fatal, "MOM_tracer: register_tracer must be called for "//&
              trim(name)//" before add_tracer_diagnostics is called for it.")
   endif
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_tracer_obc_values()

subroutine, public mom_tracer_registry::add_tracer_obc_values	(	character(len=*), intent(in)	name,
		type(tracer_registry_type), pointer	Reg,
		real, intent(in), optional	OBC_inflow,
		real, dimension(:,:,:), optional, pointer	OBC_in_u,
		real, dimension(:,:,:), optional, pointer	OBC_in_v
	)

This subroutine adds open boundary condition concentrations for a tracer that has previously been registered by a call to register_tracer.

Parameters

[in]	name	tracer name for which the diagnostic points
	reg	pointer to the tracer registry
[in]	obc_inflow	tracer value for all inflows via the OBC for which OBC_in_u or OBC_in_v are not specified (same units as tracer CONC)
	obc_in_u	tracer at inflows through u-face of tracer cells (same units as tracer CONC)
	obc_in_v	tracer at inflows through v-face of tracer cells (same units as tracer CONC)

Definition at line 174 of file MOM_tracer_registry.F90.

References mom_error_handler::mom_error().

Referenced by dome_initialization::dome_set_obc_data(), dome_tracer::initialize_dome_tracer(), and user_tracer_example::user_initialize_tracer().

   character(len=*), intent(in)               :: name        !< tracer name for which the diagnostic points
   type(tracer_registry_type), pointer        :: reg         !< pointer to the tracer registry
   real, intent(in), optional                 :: obc_inflow  !< tracer value for all inflows via the OBC
                                                             !! for which OBC_in_u or OBC_in_v are
                                                             !! not specified (same units as tracer CONC)
   real, pointer, dimension(:,:,:), optional  :: obc_in_u    !< tracer at inflows through u-face of tracer cells
                                                             !! (same units as tracer CONC)
   real, pointer, dimension(:,:,:), optional  :: obc_in_v    !< tracer at inflows through v-face of tracer cells
                                                             !! (same units as tracer CONC)
 
   integer :: m
 
   if (.not. associated(reg)) call mom_error(fatal, "add_tracer_OBC_values :"// &
        "register_tracer must be called before add_tracer_OBC_values")
 
   do m=1,reg%ntr ; if (reg%Tr(m)%name == trim(name)) exit ; enddo
 
   if (m <= reg%ntr) then
     if (present(obc_inflow)) reg%Tr(m)%OBC_inflow_conc = obc_inflow
     if (present(obc_in_u)) then ; if (associated(obc_in_u)) &
                                       reg%Tr(m)%OBC_in_u => obc_in_u ; endif
     if (present(obc_in_v)) then ; if (associated(obc_in_v)) &
                                       reg%Tr(m)%OBC_in_v => obc_in_v ; endif
   else
     call mom_error(fatal, "MOM_tracer: register_tracer must be called for "//&
              trim(name)//" before add_tracer_OBC_values is called for it.")
   endif
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lock_tracer_registry()

subroutine, public mom_tracer_registry::lock_tracer_registry ( type(tracer_registry_type), pointer Reg )

This subroutine locks the tracer registry to prevent the addition of more tracers. After locked=.true., can then register common diagnostics.

Parameters

reg	pointer to the tracer registry

Definition at line 161 of file MOM_tracer_registry.F90.

References mom_error_handler::mom_error().

Referenced by mom::initialize_mom().

   type(tracer_registry_type), pointer    :: reg    !< pointer to the tracer registry
 
   if (.not. associated(reg)) call mom_error(warning, &
     "lock_tracer_registry called with an unassocaited registry.")
 
   reg%locked = .true.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mom_tracer_chkinv()

subroutine, public mom_tracer_registry::mom_tracer_chkinv	(	character(len=*), intent(in)	mesg,
		type(ocean_grid_type), intent(in)	G,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	h,
		type(tracer_type), dimension(:), intent(in)	Tr,
		integer, intent(in)	ntr
	)

Calculates and prints the global inventory of all tracers in the registry.

Parameters

[in]	mesg	message that appears on the chksum lines
[in]	g	ocean grid structure
[in]	tr	array of all of registered tracers
[in]	h	Layer thicknesses
[in]	ntr	number of registered tracers

Definition at line 270 of file MOM_tracer_registry.F90.

References mom_error_handler::is_root_pe().

Referenced by mom_ale::ale_offline_inputs(), mom_offline_main::offline_advection_ale(), and mom_offline_main::offline_redistribute_residual().

   character(len=*),                         intent(in) :: mesg   !< message that appears on the chksum lines
   type(ocean_grid_type),                    intent(in) :: g      !< ocean grid structure
   type(tracer_type),                        intent(in) :: tr(:)  !< array of all of registered tracers
   real, dimension(SZI_(G),SZJ_(G),SZK_(G)), intent(in) :: h      !< Layer thicknesses
   integer,                                  intent(in) :: ntr    !< number of registered tracers
 
   real, dimension(SZI_(G),SZJ_(G),SZK_(G)) :: tr_inv !< Tracer inventory
   real :: total_inv
   integer :: is, ie, js, je, nz
   integer :: i, j, k, m
 
   is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = g%ke
   do m=1,ntr
     do k=1,nz ; do j=js,je ; do i=is,ie
       tr_inv(i,j,k) = tr(m)%t(i,j,k)*h(i,j,k)*g%areaT(i,j)*g%mask2dT(i,j)
     enddo ; enddo ; enddo
     total_inv = reproducing_sum(tr_inv, is, ie, js, je)
     if (is_root_pe()) write(0,'(A,1X,A5,1X,ES25.16,1X,A)') "h-point: inventory", tr(m)%name, total_inv, mesg
   enddo
 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mom_tracer_chksum()

subroutine, public mom_tracer_registry::mom_tracer_chksum	(	character(len=*), intent(in)	mesg,
		type(tracer_type), dimension(:), intent(in)	Tr,
		integer, intent(in)	ntr,
		type(ocean_grid_type), intent(in)	G
	)

This subroutine writes out chksums for tracers.

Parameters

[in]	mesg	message that appears on the chksum lines
[in]	tr	array of all of registered tracers
[in]	ntr	number of registered tracers
[in]	g	ocean grid structure

Definition at line 253 of file MOM_tracer_registry.F90.

Referenced by mom_offline_main::offline_redistribute_residual(), and mom_tracer_hor_diff::tracer_hordiff().

   character(len=*),         intent(in) :: mesg   !< message that appears on the chksum lines
   type(tracer_type),        intent(in) :: tr(:)  !< array of all of registered tracers
   integer,                  intent(in) :: ntr    !< number of registered tracers
   type(ocean_grid_type),    intent(in) :: g      !< ocean grid structure
 
   integer :: is, ie, js, je, nz
   integer :: i, j, k, m
 
   is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = g%ke
   do m=1,ntr
     call hchksum(tr(m)%t, mesg//trim(tr(m)%name), g%HI)
   enddo
 

Here is the caller graph for this function:

◆ register_tracer()

subroutine, public mom_tracer_registry::register_tracer	(	real, dimension( hi %isd: hi %ied, hi %jsd: hi %jed, gv %ke), target	tr1,
		type(vardesc), intent(in)	tr_desc,
		type(param_file_type), intent(in)	param_file,
		type(hor_index_type), intent(in)	HI,
		type(verticalgrid_type), intent(in)	GV,
		type(tracer_registry_type), pointer	Reg,
		type(vardesc), optional, target	tr_desc_ptr,
		real, dimension(:,:,:), optional, pointer	ad_x,
		real, dimension(:,:,:), optional, pointer	ad_y,
		real, dimension(:,:,:), optional, pointer	df_x,
		real, dimension(:,:,:), optional, pointer	df_y,
		real, intent(in), optional	OBC_inflow,
		real, dimension(:,:,:), optional, pointer	OBC_in_u,
		real, dimension(:,:,:), optional, pointer	OBC_in_v,
		real, dimension(:,:), optional, pointer	ad_2d_x,
		real, dimension(:,:), optional, pointer	ad_2d_y,
		real, dimension(:,:), optional, pointer	df_2d_x,
		real, dimension(:,:), optional, pointer	df_2d_y,
		real, dimension(:,:,:), optional, pointer	advection_xy
	)

This subroutine registers a tracer to be advected and laterally diffused.

Parameters

[in]	hi	horizontal index type
[in]	gv	ocean vertical grid structure
	tr1	pointer to the tracer (concentration units)
[in]	tr_desc	metadata about the tracer
[in]	param_file	file to parse for model parameter values
	reg	pointer to the tracer registry
	tr_desc_ptr	A target that can be used to set a pointer to the stored value of trtr_desc. This target must be an enduring part of the control structure, because the tracer registry will use this memory, but it also means that any updates to this structure in the calling module will be available subsequently to the tracer registry.
	ad_x	diagnostic x-advective flux (CONC m3/s or CONC*kg/s)
	ad_y	diagnostic y-advective flux (CONC m3/s or CONC*kg/s)
	df_x	diagnostic x-diffusive flux (CONC m3/s or CONC*kg/s)
	df_y	diagnostic y-diffusive flux (CONC m3/s or CONC*kg/s)
[in]	obc_inflow	the tracer for all inflows via OBC for which OBC_in_u or OBC_in_v are not specified (units of tracer CONC)
	obc_in_u	tracer at inflows through u-faces of tracer cells (units of tracer CONC)
	obc_in_v	tracer at inflows through v-faces of tracer cells (units of tracer CONC)
	ad_2d_x	vert sum of diagnostic x-advect flux (CONC m3/s or CONC*kg/s)
	ad_2d_y	vert sum of diagnostic y-advect flux (CONC m3/s or CONC*kg/s)
	df_2d_x	vert sum of diagnostic x-diffuse flux (CONC m3/s or CONC*kg/s)
	df_2d_y	vert sum of diagnostic y-diffuse flux (CONC m3/s or CONC*kg/s)
	advection_xy	convergence of lateral advective tracer fluxes

Definition at line 81 of file MOM_tracer_registry.F90.

References mom_error_handler::mom_error(), mom_io::query_vardesc(), and tracer_registry_init().

   type(hor_index_type),           intent(in)    :: hi           !< horizontal index type
   type(verticalgrid_type),        intent(in)    :: gv           !< ocean vertical grid structure
   real, dimension(SZI_(HI),SZJ_(HI),SZK_(GV)), target :: tr1    !< pointer to the tracer (concentration units)
   type(vardesc),         intent(in)             :: tr_desc      !< metadata about the tracer
   type(param_file_type), intent(in)             :: param_file   !< file to parse for  model parameter values
   type(tracer_registry_type), pointer           :: reg          !< pointer to the tracer registry
   type(vardesc), target, optional               :: tr_desc_ptr  !< A target that can be used to set a pointer to the
                                                                 !! stored value of tr%tr_desc.  This target must be an
                                                                 !! enduring part of the control structure, because the tracer
                                                                 !! registry will use this memory, but it also means that any
                                                                 !! updates to this structure in the calling module will be
                                                                 !! available subsequently to the tracer registry.
   real, pointer, dimension(:,:,:), optional     :: ad_x         !< diagnostic x-advective flux (CONC m3/s or CONC*kg/s)
   real, pointer, dimension(:,:,:), optional     :: ad_y         !< diagnostic y-advective flux (CONC m3/s or CONC*kg/s)
   real, pointer, dimension(:,:,:), optional     :: df_x         !< diagnostic x-diffusive flux (CONC m3/s or CONC*kg/s)
   real, pointer, dimension(:,:,:), optional     :: df_y         !< diagnostic y-diffusive flux (CONC m3/s or CONC*kg/s)
 
   real, intent(in),                optional     :: obc_inflow   !< the tracer for all inflows via OBC for which OBC_in_u
                                                                 !! or OBC_in_v are not specified (units of tracer CONC)
   real, pointer, dimension(:,:,:), optional     :: obc_in_u     !< tracer at inflows through u-faces of
                                                                 !! tracer cells (units of tracer CONC)
   real, pointer, dimension(:,:,:), optional     :: obc_in_v     !< tracer at inflows through v-faces of
                                                                 !! tracer cells (units of tracer CONC)
 
   real, dimension(:,:),   pointer, optional     :: ad_2d_x      !< vert sum of diagnostic x-advect flux (CONC m3/s or CONC*kg/s)
   real, dimension(:,:),   pointer, optional     :: ad_2d_y      !< vert sum of diagnostic y-advect flux (CONC m3/s or CONC*kg/s)
   real, dimension(:,:),   pointer, optional     :: df_2d_x      !< vert sum of diagnostic x-diffuse flux (CONC m3/s or CONC*kg/s)
   real, dimension(:,:),   pointer, optional     :: df_2d_y      !< vert sum of diagnostic y-diffuse flux (CONC m3/s or CONC*kg/s)
 
   real, pointer, dimension(:,:,:), optional     :: advection_xy !< convergence of lateral advective tracer fluxes
 
   integer :: ntr
   type(tracer_type) :: temp
   character(len=256) :: mesg    ! Message for error messages.
 
   if (.not. associated(reg)) call tracer_registry_init(param_file, reg)
 
   if (reg%ntr>=max_fields_) then
     write(mesg,'("Increase MAX_FIELDS_ in MOM_memory.h to at least ",I3," to allow for &
         &all the tracers being registered via register_tracer.")') reg%ntr+1
     call mom_error(fatal,"MOM register_tracer: "//mesg)
   endif
   reg%ntr = reg%ntr + 1
   ntr     = reg%ntr
 
   if (present(tr_desc_ptr)) then
     reg%Tr(ntr)%vd => tr_desc_ptr
   else
     allocate(reg%Tr(ntr)%vd) ; reg%Tr(ntr)%vd = tr_desc
   endif
 
   call query_vardesc(reg%Tr(ntr)%vd, name=reg%Tr(ntr)%name)
 
   if (reg%locked) call mom_error(fatal, &
       "MOM register_tracer was called for variable "//trim(reg%Tr(ntr)%name)//&
       " with a locked tracer registry.")
 
   reg%Tr(ntr)%t => tr1
 
   if (present(ad_x)) then ; if (associated(ad_x)) reg%Tr(ntr)%ad_x => ad_x ; endif
   if (present(ad_y)) then ; if (associated(ad_y)) reg%Tr(ntr)%ad_y => ad_y ; endif
   if (present(df_x)) then ; if (associated(df_x)) reg%Tr(ntr)%df_x => df_x ; endif
   if (present(df_y)) then ; if (associated(df_y)) reg%Tr(ntr)%df_y => df_y ; endif
   if (present(obc_inflow)) reg%Tr(ntr)%OBC_inflow_conc = obc_inflow
   if (present(obc_in_u)) then ; if (associated(obc_in_u)) &
                                     reg%Tr(ntr)%OBC_in_u => obc_in_u ; endif
   if (present(obc_in_v)) then ; if (associated(obc_in_v)) &
                                     reg%Tr(ntr)%OBC_in_v => obc_in_v ; endif
   if (present(ad_2d_x)) then ; if (associated(ad_2d_x)) reg%Tr(ntr)%ad2d_x => ad_2d_x ; endif
   if (present(ad_2d_y)) then ; if (associated(ad_2d_y)) reg%Tr(ntr)%ad2d_y => ad_2d_y ; endif
   if (present(df_2d_x)) then ; if (associated(df_2d_x)) reg%Tr(ntr)%df2d_x => df_2d_x ; endif
 
   if (present(advection_xy)) then ; if (associated(advection_xy)) reg%Tr(ntr)%advection_xy => advection_xy ; endif
 

Here is the call graph for this function:

◆ tracer_registry_end()

subroutine, public mom_tracer_registry::tracer_registry_end ( type(tracer_registry_type), pointer Reg )

This routine closes the tracer registry module.

Definition at line 321 of file MOM_tracer_registry.F90.

321 type(tracer_registry_type), pointer :: reg

322 if (associated(reg)) deallocate(reg)

◆ tracer_registry_init()

subroutine, public mom_tracer_registry::tracer_registry_init	(	type(param_file_type), intent(in)	param_file,
		type(tracer_registry_type), pointer	Reg
	)

This routine include declares and sets the variable "version".

Parameters

[in]	param_file	open file to parse for model parameters
	reg	pointer to tracer registry

Definition at line 294 of file MOM_tracer_registry.F90.

References mom_error_handler::is_root_pe(), and mom_error_handler::mom_error().

Referenced by register_tracer().

   type(param_file_type),      intent(in) :: param_file !< open file to parse for model parameters
   type(tracer_registry_type), pointer    :: reg        !< pointer to tracer registry
 
   integer, save :: init_calls = 0
 
 #include "version_variable.h"
   character(len=40)  :: mdl = "MOM_tracer_registry" ! This module's name.
   character(len=256) :: mesg    ! Message for error messages.
 
   if (.not.associated(reg)) then ; allocate(reg)
   else ; return ; endif
 
   ! Read all relevant parameters and write them to the model log.
   call log_version(param_file, mdl, version, "")
 
   init_calls = init_calls + 1
   if (init_calls > 1) then
     write(mesg,'("tracer_registry_init called ",I3, &
       &" times with different registry pointers.")') init_calls
     if (is_root_pe()) call mom_error(warning,"MOM_tracer"//mesg)
   endif
 

Here is the call graph for this function:

Here is the caller graph for this function:

Detailed Description

Data Types

Functions/Subroutines

Function/Subroutine Documentation

◆ add_tracer_diagnostics()

◆ add_tracer_obc_values()

◆ lock_tracer_registry()

◆ mom_tracer_chkinv()

◆ mom_tracer_chksum()

◆ register_tracer()

◆ tracer_registry_end()

◆ tracer_registry_init()