isomip_tracer Module Reference

Detailed Description

This module contains the routines used to set up and use a set of (one for now) dynamically passive tracers. For now, just one passive tracer is injected in the sponge layer. Set up and use passive tracers requires the following: (1) register_ISOMIP_tracer (2)

Data Types
type	isomip_tracer_cs
	tracer control structure More...
type	p3d

Functions/Subroutines
logical function, public	register_isomip_tracer (HI, GV, param_file, CS, tr_Reg, restart_CS)
	This subroutine is used to register tracer fields. More...
subroutine, public	initialize_isomip_tracer (restart, day, G, GV, h, diag, OBC, CS, ALE_sponge_CSp, diag_to_Z_CSp)
	Initializes the NTR tracer fields in tr(:,:,:,:) More...
subroutine, public	isomip_tracer_column_physics (h_old, h_new, ea, eb, fluxes, dt, G, GV, CS, evap_CFL_limit, minimum_forcing_depth)
	This subroutine applies diapycnal diffusion and any other column. More...
subroutine, public	isomip_tracer_surface_state (state, h, G, CS)
	This particular tracer package does not report anything back to the coupler. More...
subroutine, public	isomip_tracer_end (CS)

Variables
integer, parameter	ntr = 1

Function/Subroutine Documentation

initialize_isomip_tracer()

subroutine, public isomip_tracer::initialize_isomip_tracer	(	logical, intent(in)	restart,
		type(time_type), intent(in), target	day,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		real, dimension( 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(isomip_tracer_cs), pointer	CS,
		type(ale_sponge_cs), pointer	ALE_sponge_CSp,
		type(diag_to_z_cs), pointer	diag_to_Z_CSp
	)

Initializes the NTR tracer fields in tr(:,:,:,:)

Parameters

[in]	g	Grid structure.
[in]	gv	The ocean's vertical grid structure.
[in]	restart	.true. if the fields have already been read from a restart file.
[in]	day	Time of the start of the run.
[in]	h	Layer thickness, in m or kg m-2.
	obc	This open boundary condition type specifies whether, where, and what open boundary conditions are used. This is not being used for now.
	cs	The control structure returned by a previous call to ISOMIP_register_tracer.
	ale_sponge_csp	A pointer to the control structure for the sponges, if they are in use. Otherwise this may be unassociated.
	diag_to_z_csp	A pointer to the control structure for diagnostics in depth space.

Definition at line 172 of file ISOMIP_tracer.F90.

References mom_tracer_registry::add_tracer_diagnostics(), mom_error_handler::mom_error(), ntr, mom_io::query_vardesc(), and mom_diag_to_z::register_z_tracer().

  type(ocean_grid_type),                 intent(in) :: g !< Grid structure.
  type(verticalgrid_type),               intent(in) :: gv !< The ocean's vertical grid structure.
  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.
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), intent(in) :: h !< Layer thickness, in m or kg m-2.
  type(diag_ctrl), target,               intent(in) :: diag
  type(ocean_obc_type),                  pointer    :: obc !< This open boundary condition type specifies whether, where, and what open boundary conditions are used. This is not being used for now.
  type(isomip_tracer_cs),                pointer    :: cs !< The control structure returned by a previous call to ISOMIP_register_tracer.
  type(ale_sponge_cs),                   pointer    :: ale_sponge_csp !< A pointer to the control structure for the sponges, if they are in use.  Otherwise this may be unassociated.
  type(diag_to_z_cs),                    pointer    :: diag_to_z_csp !< A pointer to the control structure for diagnostics in depth space.

  real, allocatable :: temp(:,:,:)
  real, pointer, dimension(:,:,:) :: &
    obc_tr1_u => null(), & ! These arrays should be allocated and set to
    obc_tr1_v => null()    ! specify the values of tracer 1 that should come
                           ! in through u- and v- points through the open
                           ! boundary conditions, in the same units as tr.
  character(len=16) :: 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 tracer fluxes, usually
                            ! kg(tracer) kg(water)-1 m3 s-1 or kg(tracer) s-1.
  real, pointer :: tr_ptr(:,:,:) => null()
  real :: pi     ! 3.1415926... calculated as 4*atan(1)
  real :: tr_y   ! Initial zonally uniform tracer concentrations.
  real :: dist2  ! The distance squared from a line, in m2.
  real :: h_neglect         ! A thickness that is so small it is usually lost
                            ! in roundoff and can be neglected, in m.
  real :: e(szk_(g)+1), e_top, e_bot, d_tr
  integer :: i, j, k, is, ie, js, je, isd, ied, jsd, jed, nz, m
  integer :: isdb, iedb, jsdb, jedb

  if (.not.associated(cs)) return
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = g%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
  h_neglect = gv%H_subroundoff

  cs%Time => day
  cs%diag => diag

  if (.not.restart) then
    if (len_trim(cs%tracer_IC_file) >= 1) then
      !  Read the tracer concentrations from a netcdf file.
      if (.not.file_exists(cs%tracer_IC_file, g%Domain)) &
        call mom_error(fatal, "ISOMIP_initialize_tracer: Unable to open "// &
                        cs%tracer_IC_file)
      do m=1,ntr
        call query_vardesc(cs%tr_desc(m), name, caller="initialize_ISOMIP_tracer")
        call read_data(cs%tracer_IC_file, trim(name), &
                       cs%tr(:,:,:,m), domain=g%Domain%mpp_domain)
      enddo
    else
      do m=1,ntr
        do k=1,nz ; do j=js,je ; do i=is,ie
          cs%tr(i,j,k,m) = 0.0
        enddo ; enddo ; enddo
      enddo
    endif
  endif ! restart

! the following does not work in layer mode yet
!!  if ( CS%use_sponge ) then
  !   If sponges are used, this example damps tracers in sponges in the
  ! northern half of the domain to 1 and tracers in the southern half
  ! to 0.  For any tracers that are not damped in the sponge, the call
  ! to set_up_sponge_field can simply be omitted.
!    if (.not.associated(ALE_sponge_CSp)) &
!      call MOM_error(FATAL, "ISOMIP_initialize_tracer: "// &
!        "The pointer to ALEsponge_CSp must be associated if SPONGE is defined.")

!    allocate(temp(G%isd:G%ied,G%jsd:G%jed,nz))

!    do j=js,je ; do i=is,ie
!      if (G%geoLonT(i,j) >= 790.0 .AND. G%geoLonT(i,j) <= 800.0) then
!        temp(i,j,:) = 1.0
!      else
!        temp(i,j,:) = 0.0
!      endif
!    enddo ; enddo

      !   do m=1,NTR
!    do m=1,1
      ! This is needed to force the compiler not to do a copy in the sponge
      ! calls.  Curses on the designers and implementers of Fortran90.
!      tr_ptr => CS%tr(:,:,:,m)
!      call set_up_ALE_sponge_field(temp, G, tr_ptr, ALE_sponge_CSp)
!    enddo
!    deallocate(temp)
!  endif

  ! This needs to be changed if the units of tracer are changed above.
  if (gv%Boussinesq) then ; flux_units = "kg kg-1 m3 s-1"
  else ; flux_units = "kg s-1" ; endif

  do m=1,ntr
    ! Register the tracer for the restart file.
    call query_vardesc(cs%tr_desc(m), name, units=units, longname=longname, &
                       caller="initialize_ISOMIP_tracer")
    cs%id_tracer(m) = register_diag_field("ocean_model", trim(name), cs%diag%axesTL, &
        day, trim(longname) , trim(units))
    cs%id_tr_adx(m) = register_diag_field("ocean_model", trim(name)//"_adx", &
        cs%diag%axesCuL, day, trim(longname)//" advective zonal flux" , &
        trim(flux_units))
    cs%id_tr_ady(m) = register_diag_field("ocean_model", trim(name)//"_ady", &
        cs%diag%axesCvL, day, trim(longname)//" advective meridional flux" , &
        trim(flux_units))
    cs%id_tr_dfx(m) = register_diag_field("ocean_model", trim(name)//"_dfx", &
        cs%diag%axesCuL, day, trim(longname)//" diffusive zonal flux" , &
        trim(flux_units))
    cs%id_tr_dfy(m) = register_diag_field("ocean_model", trim(name)//"_dfy", &
        cs%diag%axesCvL, day, trim(longname)//" diffusive zonal flux" , &
        trim(flux_units))
    if (cs%id_tr_adx(m) > 0) call safe_alloc_ptr(cs%tr_adx(m)%p,isdb,iedb,jsd,jed,nz)
    if (cs%id_tr_ady(m) > 0) call safe_alloc_ptr(cs%tr_ady(m)%p,isd,ied,jsdb,jedb,nz)
    if (cs%id_tr_dfx(m) > 0) call safe_alloc_ptr(cs%tr_dfx(m)%p,isdb,iedb,jsd,jed,nz)
    if (cs%id_tr_dfy(m) > 0) call safe_alloc_ptr(cs%tr_dfy(m)%p,isd,ied,jsdb,jedb,nz)

!    Register the tracer for horizontal advection & diffusion.
    if ((cs%id_tr_adx(m) > 0) .or. (cs%id_tr_ady(m) > 0) .or. &
        (cs%id_tr_dfx(m) > 0) .or. (cs%id_tr_dfy(m) > 0)) &
      call add_tracer_diagnostics(name, cs%tr_Reg, cs%tr_adx(m)%p, &
                                  cs%tr_ady(m)%p, cs%tr_dfx(m)%p, cs%tr_dfy(m)%p)

    call register_z_tracer(cs%tr(:,:,:,m), trim(name), longname, units, &
                           day, g, diag_to_z_csp)
  enddo

Here is the call graph for this function:

isomip_tracer_column_physics()

subroutine, public isomip_tracer::isomip_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(isomip_tracer_cs), pointer	CS,
		real, intent(in), optional	evap_CFL_limit,
		real, intent(in), optional	minimum_forcing_depth
	)

This subroutine applies diapycnal diffusion and any other column.

Parameters

[in]	g	The ocean's grid structure
[in]	gv	The ocean's vertical grid structure
[in]	dt	The amount of time covered by this call, in s

Definition at line 308 of file ISOMIP_tracer.F90.

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

  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, h_new, ea, eb
  type(forcing),                         intent(in) :: fluxes
  real,                                  intent(in) :: dt   !< The amount of time covered by this call, in s
  type(isomip_tracer_cs),                pointer    :: cs
  real,                        optional,intent(in)  :: evap_cfl_limit
  real,                        optional,intent(in)  :: minimum_forcing_depth

! Arguments: h_old -  Layer thickness before entrainment, in m or kg m-2.
!  (in)      h_new -  Layer thickness after entrainment, in 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, in 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, in m or kg m-2.
!  (in)      fluxes - A structure containing pointers to any possible
!                     forcing fields.  Unused fields have NULL ptrs.
!  (in)      dt - The amount of time covered by this call, in s.
!  (in)      G - The ocean's grid structure.
!  (in)      GV - The ocean's vertical grid structure.
!  (in)      CS - The control structure returned by a previous call to
!                 ISOMIP_register_tracer.
!
! 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]

  real :: mmax
  real :: b1(szi_(g))          ! b1 and c1 are variables used by the
  real :: c1(szi_(g),szk_(g))  ! tridiagonal solver.
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)) :: h_work ! Used so that h can be modified
  real :: melt(szi_(g),szj_(g))  ! melt water (positive for melting
                                 ! negative for freezing)
  integer :: i, j, k, is, ie, js, je, nz, m
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = g%ke

  if (.not.associated(cs)) return

  melt(:,:) = fluxes%iceshelf_melt

  ! max. melt
  mmax = maxval(melt(is:ie,js:je))
  call max_across_pes(mmax)
  !write(*,*)'max melt', mmax
  ! dye melt water (m=1), dye = 1 if melt=max(melt)
  do m=1,ntr
     do j=js,je ; do i=is,ie
      if (melt(i,j) > 0.0) then ! melting
         !write(*,*)'i,j,melt,melt/mmax',i,j,melt(i,j),melt(i,j)/mmax
         cs%tr(i,j,1:2,m) = melt(i,j)/mmax ! inject dye in the ML
      else ! freezing
         cs%tr(i,j,1:2,m) = 0.0
      endif
    enddo ; enddo
  enddo

  if (present(evap_cfl_limit) .and. present(minimum_forcing_depth)) then
    do m=1,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,ntr
      call tracer_vertdiff(h_old, ea, eb, dt, cs%tr(:,:,:,m), g, gv)
    enddo
  endif

  if (cs%mask_tracers) then
    do m = 1,ntr ; if (cs%id_tracer(m) > 0) then
      do k=1,nz ; do j=js,je ; do i=is,ie
        if (h_new(i,j,k) < 1.1*gv%Angstrom) then
          cs%tr_aux(i,j,k,m) = cs%land_val(m)
        else
          cs%tr_aux(i,j,k,m) = cs%tr(i,j,k,m)
        endif
      enddo ; enddo ; enddo
    endif ; enddo
  endif

  do m=1,ntr
    if (cs%mask_tracers) then
      if (cs%id_tracer(m)>0) &
        call post_data(cs%id_tracer(m),cs%tr_aux(:,:,:,m),cs%diag)
    else
      if (cs%id_tracer(m)>0) &
        call post_data(cs%id_tracer(m),cs%tr(:,:,:,m),cs%diag)
    endif
    if (cs%id_tr_adx(m)>0) &
      call post_data(cs%id_tr_adx(m),cs%tr_adx(m)%p(:,:,:),cs%diag)
    if (cs%id_tr_ady(m)>0) &
      call post_data(cs%id_tr_ady(m),cs%tr_ady(m)%p(:,:,:),cs%diag)
    if (cs%id_tr_dfx(m)>0) &
      call post_data(cs%id_tr_dfx(m),cs%tr_dfx(m)%p(:,:,:),cs%diag)
    if (cs%id_tr_dfy(m)>0) &
      call post_data(cs%id_tr_dfy(m),cs%tr_dfy(m)%p(:,:,:),cs%diag)
  enddo

Here is the call graph for this function:

isomip_tracer_end()

subroutine, public isomip_tracer::isomip_tracer_end

(

type(isomip_tracer_cs), pointer

CS

)

Definition at line 436 of file ISOMIP_tracer.F90.

References ntr.

Referenced by mom_tracer_flow_control::tracer_flow_control_end().

  type(isomip_tracer_cs), pointer :: cs
  integer :: m

  if (associated(cs)) then
    if (associated(cs%tr)) deallocate(cs%tr)
    if (associated(cs%tr_aux)) deallocate(cs%tr_aux)
    do m=1,ntr
      if (associated(cs%tr_adx(m)%p)) deallocate(cs%tr_adx(m)%p)
      if (associated(cs%tr_ady(m)%p)) deallocate(cs%tr_ady(m)%p)
      if (associated(cs%tr_dfx(m)%p)) deallocate(cs%tr_dfx(m)%p)
      if (associated(cs%tr_dfy(m)%p)) deallocate(cs%tr_dfy(m)%p)
    enddo

    deallocate(cs)
  endif

Here is the caller graph for this function:

isomip_tracer_surface_state()

subroutine, public isomip_tracer::isomip_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(isomip_tracer_cs), pointer	CS
	)

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, in m or kg m-2.
	cs	The control structure returned by a previous call to ISOMIP_register_tracer.

Definition at line 415 of file ISOMIP_tracer.F90.

References ntr, and coupler_util::set_coupler_values().

  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, in m or kg m-2.
  type(isomip_tracer_cs),                     pointer       :: cs !< The control structure returned by a previous call to ISOMIP_register_tracer.
  integer :: i, j, m, is, ie, js, je, nz
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = g%ke

  if (.not.associated(cs)) return

  if (cs%coupled_tracers) then
    do m=1,ntr
      !   This call loads the surface vlues into the appropriate array in the
      ! coupler-type structure.
      call set_coupler_values(cs%tr(:,:,1,1), state%tr_fields, cs%ind_tr(m), &
                              ind_csurf, is, ie, js, je)
    enddo
  endif

Here is the call graph for this function:

register_isomip_tracer()

logical function, public isomip_tracer::register_isomip_tracer	(	type(hor_index_type), intent(in)	HI,
		type(verticalgrid_type), intent(in)	GV,
		type(param_file_type), intent(in)	param_file,
		type(isomip_tracer_cs), pointer	CS,
		type(tracer_registry_type), pointer	tr_Reg,
		type(mom_restart_cs), pointer	restart_CS
	)

This subroutine is used to register tracer fields.

Parameters

[in]	hi	A horizontal index type structure.
[in]	gv	The ocean's vertical grid structure.
[in]	param_file	A structure indicating the open file to parse for model parameter values.
	cs	A pointer that is set to point to the control structure for this module (in/out).
	tr_reg	A pointer to the tracer registry.
	restart_cs	A pointer to the restart control structure.

Definition at line 94 of file ISOMIP_tracer.F90.

References atmos_ocean_fluxes_mod::aof_set_coupler_flux(), mom_error_handler::mom_error(), ntr, and mom_io::var_desc().

  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 indicating the open file to parse for model parameter values.
  type(isomip_tracer_cs),       pointer    :: cs !<A pointer that is set to point to the control structure for this module (in/out).
  type(tracer_registry_type), pointer    :: tr_reg !<A pointer to the tracer registry.
  type(mom_restart_cs),       pointer    :: restart_cs !<A pointer to the restart control structure.

  character(len=80)  :: name, longname
! This include declares and sets the variable "version".
#include "version_variable.h"
  character(len=40)  :: mdl = "ISOMIP_tracer" ! This module's name.
  character(len=200) :: inputdir
  real, pointer :: tr_ptr(:,:,:) => null()
  logical :: register_isomip_tracer
  integer :: isd, ied, jsd, jed, nz, m
  isd = hi%isd ; ied = hi%ied ; jsd = hi%jsd ; jed = hi%jed ; nz = gv%ke

  if (associated(cs)) then
    call mom_error(warning, "ISOMIP_register_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, "ISOMIP_TRACER_IC_FILE", cs%tracer_IC_file, &
                 "The name of a file from which to read the initial \n"//&
                 "conditions for the ISOMIP tracers, or blank to initialize \n"//&
                 "them internally.", default=" ")
  if (len_trim(cs%tracer_IC_file) >= 1) then
    call get_param(param_file, mdl, "INPUTDIR", inputdir, default=".")
    inputdir = slasher(inputdir)
    cs%tracer_IC_file = trim(inputdir)//trim(cs%tracer_IC_file)
    call log_param(param_file, mdl, "INPUTDIR/ISOMIP_TRACER_IC_FILE", &
                   cs%tracer_IC_file)
  endif
  call get_param(param_file, mdl, "SPONGE", cs%use_sponge, &
                 "If true, sponges may be applied anywhere in the domain. \n"//&
                 "The exact location and properties of those sponges are \n"//&
                 "specified from MOM_initialization.F90.", default=.false.)

  allocate(cs%tr(isd:ied,jsd:jed,nz,ntr)) ; cs%tr(:,:,:,:) = 0.0
  if (cs%mask_tracers) then
    allocate(cs%tr_aux(isd:ied,jsd:jed,nz,ntr)) ; cs%tr_aux(:,:,:,:) = 0.0
  endif

  do m=1,ntr
    if (m < 10) then ; write(name,'("tr_D",I1.1)') m
    else ; write(name,'("tr_D",I2.2)') m ; endif
    write(longname,'("Concentration of ISOMIP Tracer ",I2.2)') m
    cs%tr_desc(m) = var_desc(name, units="kg kg-1", longname=longname, caller=mdl)

    ! This is needed to force the compiler not to do a copy in the registration
    ! calls.  Curses on the designers and implementers of Fortran90.
    tr_ptr => cs%tr(:,:,:,m)
    ! Register the tracer for the restart file.
    call register_restart_field(tr_ptr, cs%tr_desc(m), .true., restart_cs)
    ! Register the tracer for horizontal advection & diffusion.
    call register_tracer(tr_ptr, cs%tr_desc(m), param_file, hi, gv, tr_reg, &
                         tr_desc_ptr=cs%tr_desc(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(name)//'_flux', &
          flux_type=' ', implementation=' ', caller="register_ISOMIP_tracer")
  enddo

  cs%tr_Reg => tr_reg
  register_isomip_tracer = .true.

Here is the call graph for this function:

Variable Documentation

ntr

integer, parameter isomip_tracer::ntr = 1

private

Definition at line 49 of file ISOMIP_tracer.F90.

Referenced by initialize_isomip_tracer(), isomip_tracer_column_physics(), isomip_tracer_end(), isomip_tracer_surface_state(), and register_isomip_tracer().

integer, parameter :: ntr = 1