boundary_impulse_tracer Module Reference

Detailed Description

Implements a boundary impulse response tracer to calculate Green's functions.

Impulse Response Tracer and Transit Time Distributions

Transit time distributions (TTD) are the Green's function solution of the passive tracer equation between the oceanic surface and interior. The name derives from the idea that the 'age' (e.g. time since last contact with the atmosphere) of a water parcel is best characterized as a distribution of ages because water parcels leaving the surface arrive at a particular interior point at different times. The more commonly used ideal age tracer is the first moment of the TTD, equivalently referred to as the mean age.

A boundary impulse response (BIR) is a passive tracer whose surface boundary condition is a rectangle function with width \(\Delta t\). In the case of unsteady flow, multiple BIRs, initiated at different times in the model can be used to infer the transit time distribution or Green's function between the oceanic surface and interior. In the case of steady or cyclostationary flow, a single BIR is sufficient.

In the References section, both the theoretical discussion of TTDs and BIRs are listed along with modeling studies which have this used framework in scientific investigations

parameters

-DO_BOUNDARY_IMPULSE_TRACER: Enables the boundary impulse tracer model -IMPULSE_SOURCE_TIME: Length of time that the surface layer acts as a source of the BIR tracer

References

and BIR Theory

-Holzer, M., and T.M. Hall, 2000: Transit-time and tracer-age distributions in geophysical flows. J. Atmos. Sci., 57, 3539-3558, doi:10.1175/1520-0469(2000)057<3539:TTATAD>2.0.CO;2. -T.W.N. Haine, H. Zhang, D.W. Waugh, M. Holzer, On transit-time distributions in unsteady circulation models, Ocean Modelling, Volume 21, Issues 1–2, 2008, Pages 35-45, ISSN 1463-5003 http://dx.doi.org/10.1016/j.ocemod.2007.11.004.

Modelling applications

-Peacock, S., and M. Maltrud (2006), Transit-time distributions in a global ocean model, J. Phys. Oceanogr., 36(3), 474–495, doi:10.1175/JPO2860.1. -Maltrud, M., Bryan, F. & Peacock, Boundary impulse response functions in a century-long eddying global ocean simulation, S. Environ Fluid Mech (2010) 10: 275. doi:10.1007/s10652-009-9154-3

Data Types
type	boundary_impulse_tracer_cs
type	p3d

Functions/Subroutines
logical function, public	register_boundary_impulse_tracer (HI, GV, param_file, CS, tr_Reg, restart_CS)
	Read in runtime options and add boundary impulse tracer to tracer registry. More...
subroutine, public	initialize_boundary_impulse_tracer (restart, day, G, GV, h, diag, OBC, CS, sponge_CSp, diag_to_Z_CSp, tv)
	Initialize tracer from restart or set to 1 at surface to initialize. More...
subroutine, public	boundary_impulse_tracer_column_physics (h_old, h_new, ea, eb, fluxes, dt, G, GV, CS, tv, debug, evap_CFL_limit, minimum_forcing_depth)
integer function, public	boundary_impulse_stock (h, stocks, G, GV, CS, names, units, stock_index)
	Calculate total inventory of tracer. More...
subroutine, public	boundary_impulse_tracer_surface_state (state, h, G, CS)
	Called if returned if coupler needs to know about tracer, currently unused. More...
subroutine, public	boundary_impulse_tracer_end (CS)

Variables
integer, parameter	ntr_max = 1

Function/Subroutine Documentation

boundary_impulse_stock()

integer function, public boundary_impulse_tracer::boundary_impulse_stock	(	real, dimension(szi_(g),szj_(g),szk_(g)), intent(in)	h,
		real, dimension(:), intent(out)	stocks,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(boundary_impulse_tracer_cs), intent(in), pointer	CS,
		character(len=*), dimension(:), intent(out)	names,
		character(len=*), dimension(:), intent(out)	units,
		integer, intent(in), optional	stock_index
	)

Calculate total inventory of tracer.

Parameters

[in]	g	The ocean's grid structure
[in]	gv	The ocean's vertical grid structure
[in]	h	Layer thicknesses, in H (usually m or kg m-2)

Definition at line 395 of file boundary_impulse_tracer.F90.

References mom_io::query_vardesc().

  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    !< Layer thicknesses, in H (usually m or kg m-2)
  real, dimension(:),                         intent(  out) :: stocks
  type(boundary_impulse_tracer_cs), pointer,  intent(in   ) :: cs
  character(len=*), dimension(:),             intent(  out) :: names
  character(len=*), dimension(:),             intent(  out) :: units
  integer, optional,                          intent(in   ) :: stock_index
! This function calculates the mass-weighted integral of all tracer stocks,
! returning the number of stocks it has calculated.  If the stock_index
! is present, only the stock corresponding to that coded index is returned.

! Arguments: h - Layer thickness, in m or kg m-2.
!  (out)     stocks - the mass-weighted integrated amount of each tracer,
!                     in kg times concentration units.
!  (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
!                 register_boundary_impulse_tracer.
!  (out)     names - the names of the stocks calculated.
!  (out)     units - the units of the stocks calculated.
!  (in,opt)  stock_index - the coded index of a specific stock being sought.
! Return value: the number of stocks calculated here.
  integer :: boundary_impulse_stock
  integer :: i, j, k, is, ie, js, je, nz, m
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = gv%ke

  boundary_impulse_stock = 0
  if (.not.associated(cs)) return
  if (cs%ntr < 1) return

  if (present(stock_index)) then ; if (stock_index > 0) then
    ! Check whether this stock is available from this routine.

    ! No stocks from this routine are being checked yet.  Return 0.
    return
  endif ; endif

  do m=1,1
    call query_vardesc(cs%tr_desc(m), name=names(m), units=units(m), caller="boundary_impulse_stock")
    units(m) = trim(units(m))//" kg"
    stocks(m) = 0.0
    do k=1,nz ; do j=js,je ; do i=is,ie
      stocks(m) = stocks(m) + cs%tr(i,j,k,m) * &
                           (g%mask2dT(i,j) * g%areaT(i,j) * h(i,j,k))
    enddo ; enddo ; enddo
    stocks(m) = gv%H_to_kg_m2 * stocks(m)
  enddo

  boundary_impulse_stock = cs%ntr

Here is the call graph for this function:

boundary_impulse_tracer_column_physics()

subroutine, public boundary_impulse_tracer::boundary_impulse_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(boundary_impulse_tracer_cs), intent(inout), pointer	CS,
		type(thermo_var_ptrs), intent(in)	tv,
		logical, intent(in)	debug,
		real, intent(in), optional	evap_CFL_limit,
		real, intent(in), optional	minimum_forcing_depth
	)

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
[in]	tv	A structure pointing to various thermodynamic variables

Definition at line 283 of file boundary_impulse_tracer.F90.

References mom_tracer_diabatic::applytracerboundaryfluxesinout(), 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(boundary_impulse_tracer_cs), pointer,  intent(inout) :: cs
  type(thermo_var_ptrs),                      intent(in   ) :: tv   !< A structure pointing to various thermodynamic variables
  logical,                                    intent(in   ) :: debug
  real,                             optional, intent(in   ) :: evap_cfl_limit
  real,                             optional, intent(in   ) :: minimum_forcing_depth

!   This subroutine applies diapycnal diffusion and any other column
! tracer physics or chemistry to the tracers from this file.
! This is a simple example of a set of advected passive tracers.

! 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
!                 register_boundary_impulse_tracer.
!  (in)      tv - Thermodynamic structure with T and S
!  (in)      evap_CFL_limit - Limits how much water can be fluxed out of the top layer
!                             Stored previously in diabatic CS.
!  (in)      minimum_forcing_depth - The smallest depth over which fluxes can be applied
!                             Stored previously in diabatic CS.
!  (in)      debug - Calculates checksums
!
! 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 :: isecs_per_year = 1.0 / (365.0*86400.0)
  real :: year, h_total, scale, htot, ih_limit
  integer :: secs, days
  integer :: i, j, k, is, ie, js, je, nz, m, k_max
  real, allocatable :: local_tr(:,:,:)
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)) :: h_work ! Used so that h can be modified

  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = gv%ke

  if (.not.associated(cs)) return
  if (cs%ntr < 1) return

  ! This uses applyTracerBoundaryFluxesInOut, usually in ALE mode
  if (present(evap_cfl_limit) .and. present(minimum_forcing_depth)) then
    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(:,:,:,1), dt, fluxes, h_work, &
      evap_cfl_limit, minimum_forcing_depth)
    call tracer_vertdiff(h_work, ea, eb, dt, cs%tr(:,:,:,1), g, gv)
  else
    call tracer_vertdiff(h_old, ea, eb, dt, cs%tr(:,:,:,1), g, gv)
  endif

  ! Set surface conditions
  do m=1,1
    if(cs%remaining_source_time>0.0) then
      do k=1,cs%nkml ; do j=js,je ; do i=is,ie
        cs%tr(i,j,k,m) = 1.0
      enddo ; enddo ; enddo
      cs%remaining_source_time = cs%remaining_source_time-dt
    else
      do k=1,cs%nkml ; do j=js,je ; do i=is,ie
        cs%tr(i,j,k,m) = 0.0
      enddo ; enddo ; enddo
    endif

  enddo

  allocate(local_tr(g%isd:g%ied,g%jsd:g%jed,nz))
  do m=1,1
    if (cs%id_tracer(m)>0) then
      if (cs%mask_tracers) then
        do k=1,nz ; do j=js,je ; do i=is,ie
          if (h_new(i,j,k) < 1.1*gv%Angstrom) then
            local_tr(i,j,k) = cs%land_val(m)
          else
            local_tr(i,j,k) = cs%tr(i,j,k,m)
          endif
        enddo ; enddo ; enddo
      else
        do k=1,nz ; do j=js,je ; do i=is,ie
          local_tr(i,j,k) = cs%tr(i,j,k,m)
        enddo ; enddo ; enddo
      endif ! CS%mask_tracers
      call post_data(cs%id_tracer(m),local_tr,cs%diag)
    endif ! CS%id_tracer(m)>0
    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
  deallocate(local_tr)

Here is the call graph for this function:

boundary_impulse_tracer_end()

subroutine, public boundary_impulse_tracer::boundary_impulse_tracer_end

(

type(boundary_impulse_tracer_cs), pointer

CS

)

Definition at line 480 of file boundary_impulse_tracer.F90.

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

  if (associated(cs)) then
    if (associated(cs%tr)) deallocate(cs%tr)
    do m=1,cs%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

boundary_impulse_tracer_surface_state()

subroutine, public boundary_impulse_tracer::boundary_impulse_tracer_surface_state	(	type(surface), intent(inout)	state,
		real, dimension(szi_(g),szj_(g),szk_(g)), intent(in)	h,
		type(ocean_grid_type), intent(in)	G,
		type(boundary_impulse_tracer_cs), intent(in), pointer	CS
	)

Called if returned if coupler needs to know about tracer, currently unused.

Parameters

[in]	g	The ocean's grid structure
[in]	h	Layer thicknesses, in H (usually m or kg m-2)

Definition at line 450 of file boundary_impulse_tracer.F90.

References coupler_util::set_coupler_values().

  type(ocean_grid_type),                    intent(in   ) :: g    !< The ocean's grid structure
  type(surface),                            intent(inout) :: state
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), intent(in   ) :: h    !< Layer thicknesses, in H (usually m or kg m-2)
  type(boundary_impulse_tracer_cs), pointer,intent(in   ) :: cs
!   This particular tracer package does not report anything back to the coupler.
! The code that is here is just a rough guide for packages that would.
! Arguments: state - A structure containing fields that describe the
!                    surface state of the ocean.
!  (in)      h - Layer thickness, in m or kg m-2.
!  (in)      G - The ocean's grid structure.
!  (in)      CS - The control structure returned by a previous call to
!                 register_boundary_impulse_tracer.
  integer :: m, is, ie, js, je
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec

  if (.not.associated(cs)) return

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

Here is the call graph for this function:

initialize_boundary_impulse_tracer()

subroutine, public boundary_impulse_tracer::initialize_boundary_impulse_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(szi_(g),szj_(g),szk_(g)), intent(in)	h,
		type(diag_ctrl), intent(in), target	diag,
		type(ocean_obc_type), intent(inout), pointer	OBC,
		type(boundary_impulse_tracer_cs), intent(inout), pointer	CS,
		type(sponge_cs), intent(inout), pointer	sponge_CSp,
		type(diag_to_z_cs), intent(inout), pointer	diag_to_Z_CSp,
		type(thermo_var_ptrs), intent(in)	tv
	)

Initialize tracer from restart or set to 1 at surface to initialize.

Parameters

[in]	g	The ocean's grid structure
[in]	gv	The ocean's vertical grid structure
[in]	h	Layer thicknesses, in H (usually m or kg m-2)
[in]	tv	A structure pointing to various thermodynamic variables

Definition at line 175 of file boundary_impulse_tracer.F90.

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

  logical,                                  intent(in   ) :: restart
  type(time_type), target,                  intent(in   ) :: day
  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    !< Layer thicknesses, in H (usually m or kg m-2)
  type(diag_ctrl), target,                  intent(in   ) :: diag
  type(ocean_obc_type), pointer,            intent(inout) :: obc
  type(boundary_impulse_tracer_cs), pointer,intent(inout) :: cs
  type(sponge_cs), pointer,                 intent(inout) :: sponge_csp
  type(diag_to_z_cs), pointer,              intent(inout) :: diag_to_z_csp
  type(thermo_var_ptrs),                    intent(in   ) :: tv   !< A structure pointing to various thermodynamic variables
!   This subroutine initializes the CS%ntr tracer fields in tr(:,:,:,:)
! and it sets up the tracer output.

! Arguments: restart - .true. if the fields have already been read from
!                     a restart file.
!  (in)      day - Time of the start of the run.
!  (in)      G - The ocean's grid structure.
!  (in)      GV - The ocean's vertical grid structure.
!  (in)      h - Layer thickness, in m or kg m-2.
!  (in)      diag - A structure that is used to regulate diagnostic output.
!  (in)      OBC - This open boundary condition type specifies whether, where,
!                  and what open boundary conditions are used.
!  (in/out)  CS - The control structure returned by a previous call to
!                 register_boundary_impulse_tracer.
!  (in/out)  sponge_CSp - A pointer to the control structure for the sponges, if
!                         they are in use.  Otherwise this may be unassociated.
!  (in/out)  diag_to_Z_Csp - A pointer to the control structure for diagnostics
!                            in depth space.
  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 age tracer fluxes, either
                                ! years m3 s-1 or years kg s-1.
  logical :: ok
  integer :: i, j, k, is, ie, js, je, isd, ied, jsd, jed, nz, m
  integer :: isdb, iedb, jsdb, jedb

  if (.not.associated(cs)) return
  if (cs%ntr < 1) return
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = gv%ke
  isd = g%isd ; ied = g%ied ; jsd = g%jsd ; jed = g%jed
  isdb = g%IsdB ; iedb = g%IedB ; jsdb = g%JsdB ; jedb = g%JedB

  cs%Time => day
  cs%diag => diag
  name = "boundary_impulse"

  do m=1,cs%ntr
    call query_vardesc(cs%tr_desc(m), name=name, caller="initialize_boundary_impulse_tracer")
    if ((.not.restart) .or. (.not. &
        query_initialized(cs%tr(:,:,:,m), name, cs%restart_CSp))) then
      do k=1,cs%nkml ; do j=jsd,jed ; do i=isd,ied
        cs%tr(i,j,k,m) = 1.0
      enddo ; enddo ; enddo
    endif
  enddo ! Tracer loop

  if (associated(obc)) then
  ! All tracers but the first have 0 concentration in their inflows. As this
  ! is the default value, the following calls are unnecessary.
  ! do m=1,CS%ntr
  !  call add_tracer_OBC_values(trim(CS%tr_desc(m)%name), CS%tr_Reg, 0.0)
  ! enddo
  endif

  ! This needs to be changed if the units of tracer are changed above.
  if (gv%Boussinesq) then ; flux_units = "g salt/(m^2 s)"
  else ; flux_units = "g salt/(m^2 s)" ; endif

  do m=1,cs%ntr
    ! Register the tracer for the restart file.
    call query_vardesc(cs%tr_desc(m), name, units=units, longname=longname, &
                       caller="initialize_boundary_impulse_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:

register_boundary_impulse_tracer()

logical function, public boundary_impulse_tracer::register_boundary_impulse_tracer	(	type(hor_index_type), intent(in)	HI,
		type(verticalgrid_type), intent(in)	GV,
		type(param_file_type), intent(in)	param_file,
		type(boundary_impulse_tracer_cs), intent(inout), pointer	CS,
		type(tracer_registry_type), intent(inout), pointer	tr_Reg,
		type(mom_restart_cs), intent(inout), pointer	restart_CS
	)

Read in runtime options and add boundary impulse tracer to tracer registry.

Parameters

[in]	gv	The ocean's vertical grid structure
[in]	param_file	A structure to parse for run-time parameters

Definition at line 84 of file boundary_impulse_tracer.F90.

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

  type(hor_index_type),                       intent(in   ) :: hi
  type(verticalgrid_type),                    intent(in   ) :: gv   !< The ocean's vertical grid structure
  type(param_file_type),                      intent(in   ) :: param_file !< A structure to parse for run-time parameters
  type(boundary_impulse_tracer_cs), pointer,  intent(inout)    :: cs
  type(tracer_registry_type),       pointer,  intent(inout) :: tr_reg
  type(mom_restart_cs),             pointer,  intent(inout) :: restart_cs
! This subroutine is used to register tracer fields and subroutines
! to be used with MOM.
! Arguments: 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.
!  (in/out)  CS - A pointer that is set to point to the control structure
!                 for this module
!  (in/out)  tr_Reg - A pointer that is set to point to the control structure
!                  for the tracer advection and diffusion module.
!  (in)      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 = "boundary_impulse_tracer" ! This module's name.
  character(len=200) :: inputdir ! The directory where the input files are.
  character(len=48)  :: var_name ! The variable's name.
  character(len=3)   :: name_tag ! String for creating identifying boundary_impulse
  real, pointer :: tr_ptr(:,:,:) => null()
  real, pointer :: rem_time_ptr => null()
  logical :: register_boundary_impulse_tracer
  integer :: isd, ied, jsd, jed, nz, m, i, j
  isd = hi%isd ; ied = hi%ied ; jsd = hi%jsd ; jed = hi%jed ; nz = gv%ke

  if (associated(cs)) then
    call mom_error(warning, "register_boundary_impulse_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, "IMPULSE_SOURCE_TIME", cs%remaining_source_time, &
                 "Length of time for the boundary tracer to be injected\n"//&
                 "into the mixed layer. After this time has elapsed, the\n"//&
                 "surface becomes a sink for the boundary impulse tracer.", &
                 default=31536000.0)
  call get_param(param_file, mdl, "TRACERS_MAY_REINIT", cs%tracers_may_reinit, &
                 "If true, tracers may go through the initialization code \n"//&
                 "if they are not found in the restart files.  Otherwise \n"//&
                 "it is a fatal error if the tracers are not found in the \n"//&
                 "restart files of a restarted run.", default=.false.)
  cs%ntr = ntr_max
  allocate(cs%tr(isd:ied,jsd:jed,nz,cs%ntr)) ; cs%tr(:,:,:,:) = 0.0

  cs%nkml = max(gv%nkml,1)

  do m=1,cs%ntr
    ! This is needed to force the compiler not to do a copy in the registration
    ! calls.  Curses on the designers and implementers of Fortran90.
    cs%tr_desc(m) = var_desc(trim("boundary_impulse"), "kg", &
        "Boundary impulse tracer", caller=mdl)
    tr_ptr => cs%tr(:,:,:,m)
    call query_vardesc(cs%tr_desc(m), name=var_name, caller="register_boundary_impulse_tracer")
    ! Register the tracer for the restart file.
    call register_restart_field(tr_ptr, cs%tr_desc(m), &
                                .not. cs%tracers_may_reinit, 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(var_name)//'_flux', &
          flux_type=' ', implementation=' ', caller="register_boundary_impulse_tracer")
  enddo
  ! Register remaining source time as a restart field
  rem_time_ptr => cs%remaining_source_time
  call register_restart_field(rem_time_ptr,                                                                 &
                              var_desc(trim("bir_remain_time"), "s", "Remaining time to apply BIR source",  &
                                             hor_grid = "1", z_grid = "1", caller=mdl),                     &
                              .not. cs%tracers_may_reinit, restart_cs)

  cs%tr_Reg => tr_reg
  cs%restart_CSp => restart_cs
  register_boundary_impulse_tracer = .true.

Here is the call graph for this function:

Variable Documentation

ntr_max

integer, parameter boundary_impulse_tracer::ntr_max = 1

private

Definition at line 37 of file boundary_impulse_tracer.F90.

Referenced by register_boundary_impulse_tracer().

integer, parameter :: ntr_max = 1