oil_tracer Module Reference

Detailed Description

A tracer package to mimic dissolved oil.

By Alistair Adcroft and Robert Hallberg, 2010 *

In the midst of the Deepwater Horizon oil spill, it became evident that models were needed to predict the long-term fate of dissolved oil in the open ocean. This tracer packages mimics the transport, dilution and decay of dissolved oil plumes in the ocean.

This tracer package was central to the simulations used by Adcroft et al., GRL 2010, to prove that the Deepwater Horizon spill was an important regional event, with implications for dissolved oxygen levels in the Gulf of Mexico, but not one that would directly impact the East Coast of the U.S.

Data Types
type	oil_tracer_cs
	The control structure for the oil tracer package. More...

Functions/Subroutines
logical function, public	register_oil_tracer (HI, GV, US, param_file, CS, tr_Reg, restart_CS)
	Register oil tracer fields and subroutines to be used with MOM. More...
subroutine, public	initialize_oil_tracer (restart, day, G, GV, US, h, diag, OBC, CS, sponge_CSp)
	Initialize the oil tracers and set up tracer output. More...
subroutine, public	oil_tracer_column_physics (h_old, h_new, ea, eb, fluxes, dt, G, GV, US, CS, tv, evap_CFL_limit, minimum_forcing_depth)
	Apply sources, sinks, diapycnal mixing and rising motions to the oil tracers. More...
integer function, public	oil_stock (h, stocks, G, GV, CS, names, units, stock_index)
	Calculate the mass-weighted integral of the oil 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. More...
subroutine, public	oil_tracer_surface_state (state, h, G, CS)
	This subroutine extracts the surface fields from this tracer package that are to be shared with the atmosphere in coupled configurations. This particular tracer package does not report anything back to the coupler. More...
subroutine, public	oil_tracer_end (CS)
	Deallocate memory associated with this tracer package. More...

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

Function/Subroutine Documentation

initialize_oil_tracer()

subroutine, public oil_tracer::initialize_oil_tracer	(	logical, intent(in)	restart,
		type(time_type), intent(in), target	day,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(unit_scale_type), intent(in)	US,
		real, dimension( g %isd: g %ied, g %jsd: g %jed, g %ke), intent(in)	h,
		type(diag_ctrl), intent(in), target	diag,
		type(ocean_obc_type), pointer	OBC,
		type(oil_tracer_cs), pointer	CS,
		type(sponge_cs), pointer	sponge_CSp
	)

Initialize the oil tracers and set up tracer output.

Parameters

[in]	restart	.true. if the fields have already been read from a restart file.
[in]	day	Time of the start of the run.
[in]	g	The ocean's grid structure
[in]	gv	The ocean's vertical grid structure
[in]	us	A dimensional unit scaling type
[in]	h	Layer thicknesses [H ~> m or kg m-2]
[in]	diag	A structure that is used to regulate diagnostic output.
	obc	This open boundary condition type specifies whether, where, and what open boundary conditions are used.
	cs	The control structure returned by a previous call to register_oil_tracer.
	sponge_csp	Pointer to the control structure for the sponges.

Definition at line 206 of file oil_tracer.F90.

  logical,                            intent(in) :: restart !< .true. if the fields have already
                                                         !! been read from a restart file.
  type(time_type),            target, intent(in) :: day  !< Time of the start of the run.
  type(ocean_grid_type),              intent(in) :: G    !< The ocean's grid structure
  type(verticalGrid_type),            intent(in) :: GV   !< The ocean's vertical grid structure
  type(unit_scale_type),              intent(in) :: US   !< A dimensional unit scaling type
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                                      intent(in) :: h    !< Layer thicknesses [H ~> m or kg m-2]
  type(diag_ctrl),            target, intent(in) :: diag !< A structure that is used to regulate
                                                         !! diagnostic output.
  type(ocean_OBC_type),               pointer    :: OBC  !< This open boundary condition type specifies
                                                         !! whether, where, and what open boundary
                                                         !! conditions are used.
  type(oil_tracer_CS),                pointer    :: CS !< The control structure returned by a previous
                                                       !! call to register_oil_tracer.
  type(sponge_CS),                    pointer    :: sponge_CSp !< Pointer to the control structure for the sponges.
 
  ! Local variables
  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
 
  ! Establish location of source
  do j=g%jsdB+1,g%jed ; do i=g%isdB+1,g%ied
    ! This test for i,j index is specific to a lat/lon (non-rotated grid).
    ! and needs to be generalized to work properly on the tri-polar grid.
    if (cs%oil_source_longitude<g%geoLonBu(i,j) .and. &
        cs%oil_source_longitude>=g%geoLonBu(i-1,j) .and. &
        cs%oil_source_latitude<g%geoLatBu(i,j) .and. &
        cs%oil_source_latitude>=g%geoLatBu(i,j-1) ) then
      cs%oil_source_i=i
      cs%oil_source_j=j
    endif
  enddo ; enddo
 
  cs%Time => day
  cs%diag => diag
 
  do m=1,cs%ntr
    call query_vardesc(cs%tr_desc(m), name=name, caller="initialize_oil_tracer")
    if ((.not.restart) .or. (cs%oil_may_reinit .and. .not. &
        query_initialized(cs%tr(:,:,:,m), name, cs%restart_CSp))) then
 
      if (len_trim(cs%IC_file) > 0) then
  !  Read the tracer concentrations from a netcdf file.
        if (.not.file_exists(cs%IC_file, g%Domain)) &
          call mom_error(fatal, "initialize_oil_tracer: "// &
                                 "Unable to open "//cs%IC_file)
 
        if (cs%Z_IC_file) then
          ok = tracer_z_init(cs%tr(:,:,:,m), h, cs%IC_file, name, &
                             g, us, -1e34, 0.0) ! CS%land_val(m))
          if (.not.ok) then
            ok = tracer_z_init(cs%tr(:,:,:,m), h, cs%IC_file, &
                     trim(name), g, us, -1e34, 0.0) ! CS%land_val(m))
            if (.not.ok) call mom_error(fatal,"initialize_oil_tracer: "//&
                    "Unable to read "//trim(name)//" from "//&
                    trim(cs%IC_file)//".")
          endif
        else
          call mom_read_data(cs%IC_file, trim(name), cs%tr(:,:,:,m), g%Domain)
        endif
      else
        do k=1,nz ; do j=js,je ; do i=is,ie
          if (g%mask2dT(i,j) < 0.5) then
            cs%tr(i,j,k,m) = cs%land_val(m)
          else
            cs%tr(i,j,k,m) = cs%IC_val(m)
          endif
        enddo ; enddo ; enddo
      endif
 
    endif ! restart
  enddo ! Tracer loop
 
  if (associated(obc)) then
  ! Put something here...
  endif
 

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

Here is the call graph for this function:

oil_stock()

integer function, public oil_tracer::oil_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(oil_tracer_cs), pointer	CS,
		character(len=*), dimension(:), intent(out)	names,
		character(len=*), dimension(:), intent(out)	units,
		integer, intent(in), optional	stock_index
	)

Calculate the mass-weighted integral of the oil 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.

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]	stocks	the mass-weighted integrated amount of each tracer, in kg times concentration units [kg conc].
	cs	The control structure returned by a previous call to register_oil_tracer.
[out]	names	the names of the stocks calculated.
[out]	units	the units of the stocks calculated.
[in]	stock_index	the coded index of a specific stock being sought.

Returns

The number of stocks calculated here.

Definition at line 408 of file oil_tracer.F90.

  type(ocean_grid_type),              intent(in)    :: G    !< The ocean's grid structure
  type(verticalGrid_type),            intent(in)    :: GV   !< The ocean's vertical grid structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), intent(in) :: h    !< Layer thicknesses [H ~> m or kg m-2]
  real, dimension(:),                 intent(out)   :: stocks !< the mass-weighted integrated amount of each
                                                              !! tracer, in kg times concentration units [kg conc].
  type(oil_tracer_CS),                pointer       :: CS   !< The control structure returned by a previous
                                                            !! call to register_oil_tracer.
  character(len=*), dimension(:),     intent(out)   :: names  !< the names of the stocks calculated.
  character(len=*), dimension(:),     intent(out)   :: units  !< the units of the stocks calculated.
  integer, optional,                  intent(in)    :: stock_index !< the coded index of a specific stock
                                                                   !! being sought.
  integer                                           :: oil_stock !< The number of stocks calculated here.
 
! This function calculates the mass-weighted integral of all tracer stocks,
! returning the number of stocks it has calculated.  If the stock_index
! is present, only the stock corresponding to that coded index is returned.
 
  ! Local variables
  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
 
  oil_stock = 0
  if (.not.associated(cs)) return
  if (cs%ntr < 1) return
 
  if (present(stock_index)) then ; if (stock_index > 0) then
    ! Check whether this stock is available from this routine.
 
    ! No stocks from this routine are being checked yet.  Return 0.
    return
  endif ; endif
 
  do m=1,cs%ntr
    call query_vardesc(cs%tr_desc(m), name=names(m), units=units(m), caller="oil_stock")
    units(m) = trim(units(m))//" kg"
    stocks(m) = 0.0
    do k=1,nz ; do j=js,je ; do i=is,ie
      stocks(m) = stocks(m) + cs%tr(i,j,k,m) * &
                             (g%mask2dT(i,j) * g%US%L_to_m**2*g%areaT(i,j) * h(i,j,k))
    enddo ; enddo ; enddo
    stocks(m) = gv%H_to_kg_m2 * stocks(m)
  enddo
  oil_stock = cs%ntr
 

References mom_io::query_vardesc().

Referenced by mom_tracer_flow_control::call_tracer_stocks().

Here is the call graph for this function:

Here is the caller graph for this function:

oil_tracer_column_physics()

subroutine, public oil_tracer::oil_tracer_column_physics	(	real, dimension(szi_(g),szj_(g),szk_(g)), intent(in)	h_old,
		real, dimension(szi_(g),szj_(g),szk_(g)), intent(in)	h_new,
		real, dimension(szi_(g),szj_(g),szk_(g)), intent(in)	ea,
		real, dimension(szi_(g),szj_(g),szk_(g)), intent(in)	eb,
		type(forcing), intent(in)	fluxes,
		real, intent(in)	dt,
		type(ocean_grid_type), intent(in)	G,
		type(verticalgrid_type), intent(in)	GV,
		type(unit_scale_type), intent(in)	US,
		type(oil_tracer_cs), pointer	CS,
		type(thermo_var_ptrs), intent(in)	tv,
		real, intent(in), optional	evap_CFL_limit,
		real, intent(in), optional	minimum_forcing_depth
	)

Apply sources, sinks, diapycnal mixing and rising motions to the oil tracers.

Parameters

[in]	g	The ocean's grid structure
[in]	gv	The ocean's vertical grid structure
[in]	h_old	Layer thickness before entrainment [H ~> m or kg m-2].
[in]	h_new	Layer thickness after entrainment [H ~> m or kg m-2].
[in]	ea	an array to which the amount of fluid entrained
[in]	eb	an array to which the amount of fluid entrained
[in]	fluxes	A structure containing pointers to thermodynamic and tracer forcing fields. Unused fields have NULL ptrs.
[in]	dt	The amount of time covered by this call [T ~> s]
[in]	us	A dimensional unit scaling type
	cs	The control structure returned by a previous call to register_oil_tracer.
[in]	tv	A structure pointing to various thermodynamic variables
[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 301 of file oil_tracer.F90.

  type(ocean_grid_type),   intent(in) :: G    !< The ocean's grid structure
  type(verticalGrid_type), intent(in) :: GV   !< The ocean's vertical grid structure
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                           intent(in) :: h_old !< Layer thickness before entrainment [H ~> m or kg m-2].
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                           intent(in) :: h_new !< Layer thickness after entrainment [H ~> m or kg m-2].
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                           intent(in) :: ea   !< an array to which the amount of fluid entrained
                                              !! from the layer above during this call will be
                                              !! added [H ~> m or kg m-2].
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                           intent(in) :: eb   !< an array to which the amount of fluid entrained
                                              !! from the layer below during this call will be
                                              !! added [H ~> m or kg m-2].
  type(forcing),           intent(in) :: fluxes !< A structure containing pointers to thermodynamic
                                              !! and tracer forcing fields.  Unused fields have NULL ptrs.
  real,                    intent(in) :: dt   !< The amount of time covered by this call [T ~> s]
  type(unit_scale_type),   intent(in) :: US   !< A dimensional unit scaling type
  type(oil_tracer_CS),     pointer    :: CS   !< The control structure returned by a previous
                                              !! call to register_oil_tracer.
  type(thermo_var_ptrs),   intent(in) :: tv   !< A structure pointing to various thermodynamic variables
  real,          optional, intent(in) :: evap_CFL_limit !< Limit on the fraction of the water that can
                                              !! be fluxed out of the top layer in a timestep [nondim]
  real,          optional, intent(in) :: minimum_forcing_depth !< The smallest depth over which
                                              !! fluxes can be applied [H ~> m or kg m-2]
!   This subroutine applies diapycnal diffusion and any other column
! tracer physics or chemistry to the tracers from this file.
! This is a simple example of a set of advected passive tracers.
 
! The arguments to this subroutine are redundant in that
!     h_new(k) = h_old(k) + ea(k) - eb(k-1) + eb(k) - ea(k+1)
 
  ! Local variables
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)) :: h_work ! Used so that h can be modified
  real :: Isecs_per_year = 1.0 / (365.0*86400.0)
  real :: year, h_total, ldecay
  integer :: i, j, k, is, ie, js, je, nz, m, k_max
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec ; nz = gv%ke
 
  if (.not.associated(cs)) return
  if (cs%ntr < 1) return
 
  if (present(evap_cfl_limit) .and. present(minimum_forcing_depth)) then
    do m=1,cs%ntr
      do k=1,nz ;do j=js,je ; do i=is,ie
        h_work(i,j,k) = h_old(i,j,k)
      enddo ; enddo ; enddo
      call applytracerboundaryfluxesinout(g, gv, cs%tr(:,:,:,m), dt, fluxes, h_work, &
                                          evap_cfl_limit, minimum_forcing_depth)
      call tracer_vertdiff(h_work, ea, eb, dt, cs%tr(:,:,:,m), g, gv)
    enddo
  else
    do m=1,cs%ntr
      call tracer_vertdiff(h_old, ea, eb, dt, cs%tr(:,:,:,m), g, gv)
    enddo
  endif
 
  year = time_type_to_real(cs%Time) * isecs_per_year
 
  ! Decay tracer (limit decay rate to 1/dt - just in case)
  do m=2,cs%ntr
    do k=1,nz ; do j=js,je ; do i=is,ie
      !CS%tr(i,j,k,m) = CS%tr(i,j,k,m) - dt*CS%oil_decay_rate(m)*CS%tr(i,j,k,m) ! Simple
      !CS%tr(i,j,k,m) = CS%tr(i,j,k,m) - min(dt*CS%oil_decay_rate(m),1.)*CS%tr(i,j,k,m) ! Safer
      if (cs%oil_decay_rate(m)>0.) then
        cs%tr(i,j,k,m) = g%mask2dT(i,j)*max(1. - dt*cs%oil_decay_rate(m),0.)*cs%tr(i,j,k,m) ! Safest
      elseif (cs%oil_decay_rate(m)<0.) then
        ldecay = 12.*(3.0**(-(tv%T(i,j,k)-20.)/10.)) ! Timescale [days]
        ldecay = 1. / (86400.*us%s_to_T * ldecay) ! Rate [T-1 ~> s-1]
        cs%tr(i,j,k,m) = g%mask2dT(i,j)*max(1. - dt*ldecay,0.)*cs%tr(i,j,k,m)
      endif
    enddo ; enddo ; enddo
  enddo
 
  ! Add oil at the source location
  if (year>=cs%oil_start_year .and. year<=cs%oil_end_year .and. &
      cs%oil_source_i>-999 .and. cs%oil_source_j>-999) then
    i=cs%oil_source_i ; j=cs%oil_source_j
    k_max=nz ; h_total=0.
    do k=nz, 2, -1
      h_total = h_total + h_new(i,j,k)
      if (h_total<10.) k_max=k-1 ! Find bottom most interface that is 10 m above bottom
    enddo
    do m=1,cs%ntr
      k=cs%oil_source_k(m)
      if (k>0) then
        k=min(k,k_max) ! Only insert k or first layer with interface 10 m above bottom
        cs%tr(i,j,k,m) = cs%tr(i,j,k,m) + cs%oil_source_rate*dt / &
                ((h_new(i,j,k)+gv%H_subroundoff) * g%US%L_to_m**2*g%areaT(i,j) )
      elseif (k<0) then
        h_total=gv%H_subroundoff
        do k=1, nz
          h_total = h_total + h_new(i,j,k)
        enddo
        do k=1, nz
          cs%tr(i,j,k,m) = cs%tr(i,j,k,m) + cs%oil_source_rate*dt/(h_total &
                                           * g%US%L_to_m**2*g%areaT(i,j) )
        enddo
      endif
    enddo
  endif
 

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

Here is the call graph for this function:

oil_tracer_end()

subroutine, public oil_tracer::oil_tracer_end

(

type(oil_tracer_cs), pointer

CS

)

Deallocate memory associated with this tracer package.

Parameters

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

Definition at line 489 of file oil_tracer.F90.

  type(oil_tracer_CS), pointer :: CS !< The control structure returned by a previous
                                     !! call to register_oil_tracer.
  integer :: m
 
  if (associated(cs)) then
    if (associated(cs%tr)) deallocate(cs%tr)
    deallocate(cs)
  endif

oil_tracer_surface_state()

subroutine, public oil_tracer::oil_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(oil_tracer_cs), pointer	CS
	)

This subroutine extracts the surface fields from this tracer package that are to be shared with the atmosphere in coupled configurations. This particular tracer package does not report anything back to the coupler.

Parameters

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

Definition at line 458 of file oil_tracer.F90.

  type(ocean_grid_type),  intent(in)    :: G  !< The ocean's grid structure.
  type(surface),          intent(inout) :: state !< A structure containing fields that
                                              !! describe the surface state of the ocean.
  real, dimension(SZI_(G),SZJ_(G),SZK_(G)), &
                          intent(in)    :: h  !< Layer thickness [H ~> m or kg m-2].
  type(oil_tracer_CS),    pointer       :: CS !< The control structure returned by a previous
                                              !! call to register_oil_tracer.
 
  ! This particular tracer package does not report anything back to the coupler.
  ! The code that is here is just a rough guide for packages that would.
 
  integer :: m, is, ie, js, je, isd, ied, jsd, jed
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
  isd = g%isd ; ied = g%ied ; jsd = g%jsd ; jed = g%jed
 
  if (.not.associated(cs)) return
 
  if (cs%coupled_tracers) then
    do m=1,cs%ntr
      !   This call loads the surface values into the appropriate array in the
      ! coupler-type structure.
      call coupler_type_set_data(cs%tr(:,:,1,m), cs%ind_tr(m), ind_csurf, &
                   state%tr_fields, idim=(/isd, is, ie, ied/), &
                   jdim=(/jsd, js, je, jed/) )
    enddo
  endif
 

register_oil_tracer()

logical function, public oil_tracer::register_oil_tracer	(	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(oil_tracer_cs), pointer	CS,
		type(tracer_registry_type), pointer	tr_Reg,
		type(mom_restart_cs), pointer	restart_CS
	)

Register oil tracer fields and subroutines to be used with MOM.

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 78 of file oil_tracer.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(oil_tracer_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
 
  ! Local variables
  character(len=40)  :: mdl = "oil_tracer" ! This module's name.
! This include declares and sets the variable "version".
#include "version_variable.h"
  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 oils
  character(len=48) :: flux_units ! The units for tracer fluxes, here
                            ! kg(oil) s-1 or kg(oil) m-3 kg(water) s-1.
  real, pointer :: tr_ptr(:,:,:) => null()
  logical :: register_oil_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_oil_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, "OIL_IC_FILE", cs%IC_file, &
                 "The file in which the oil tracer initial values can be "//&
                 "found, or an empty string for internal initialization.", &
                 default=" ")
  if ((len_trim(cs%IC_file) > 0) .and. (scan(cs%IC_file,'/') == 0)) then
    ! Add the directory if CS%IC_file is not already a complete path.
    call get_param(param_file, mdl, "INPUTDIR", inputdir, default=".")
    cs%IC_file = trim(slasher(inputdir))//trim(cs%IC_file)
    call log_param(param_file, mdl, "INPUTDIR/CFC_IC_FILE", cs%IC_file)
  endif
  call get_param(param_file, mdl, "OIL_IC_FILE_IS_Z", cs%Z_IC_file, &
                 "If true, OIL_IC_FILE is in depth space, not layer space", &
                 default=.false.)
 
  call get_param(param_file, mdl, "OIL_MAY_REINIT", cs%oil_may_reinit, &
                 "If true, oil tracers may go through the initialization "//&
                 "code if they are not found in the restart files. "//&
                 "Otherwise it is a fatal error if the oil tracers are not "//&
                 "found in the restart files of a restarted run.", &
                 default=.false.)
  call get_param(param_file, mdl, "OIL_SOURCE_LONGITUDE", cs%oil_source_longitude, &
                 "The geographic longitude of the oil source.", units="degrees E", &
                 fail_if_missing=.true.)
  call get_param(param_file, mdl, "OIL_SOURCE_LATITUDE", cs%oil_source_latitude, &
                 "The geographic latitude of the oil source.", units="degrees N", &
                 fail_if_missing=.true.)
  call get_param(param_file, mdl, "OIL_SOURCE_LAYER", cs%oil_source_k, &
                 "The layer into which the oil is introduced, or a "//&
                 "negative number for a vertically uniform source, "//&
                 "or 0 not to use this tracer.", units="Layer", default=0)
  call get_param(param_file, mdl, "OIL_SOURCE_RATE", cs%oil_source_rate, &
                 "The rate of oil injection.", units="kg s-1", scale=us%T_to_s, default=1.0)
  call get_param(param_file, mdl, "OIL_DECAY_DAYS", cs%oil_decay_days, &
                 "The decay timescale in days (if positive), or no decay "//&
                 "if 0, or use the temperature dependent decay rate of "//&
                 "Adcroft et al. (GRL, 2010) if negative.", units="days", &
                 default=0.0)
  call get_param(param_file, mdl, "OIL_DATED_START_YEAR", cs%oil_start_year, &
                 "The time at which the oil source starts", units="years", &
                 default=0.0)
  call get_param(param_file, mdl, "OIL_DATED_END_YEAR", cs%oil_end_year, &
                 "The time at which the oil source ends", units="years", &
                 default=1.0e99)
 
  cs%ntr = 0
  cs%oil_decay_rate(:) = 0.
  do m=1,ntr_max
    if (cs%oil_source_k(m)/=0) then
      write(name_tag(1:3),'("_",I2.2)') m
      cs%ntr = cs%ntr + 1
      cs%tr_desc(m) = var_desc("oil"//trim(name_tag), "kg m-3", "Oil Tracer", caller=mdl)
      cs%IC_val(m) = 0.0
      if (cs%oil_decay_days(m)>0.) then
        cs%oil_decay_rate(m) = 1. / (86400.0*us%s_to_T * cs%oil_decay_days(m))
      elseif (cs%oil_decay_days(m)<0.) then
        cs%oil_decay_rate(m) = -1.
      endif
    endif
  enddo
  call log_param(param_file, mdl, "OIL_DECAY_RATE", us%s_to_T*cs%oil_decay_rate(1:cs%ntr))
 
  ! This needs to be changed if the units of tracer are changed above.
  if (gv%Boussinesq) then ; flux_units = "kg s-1"
  else ; flux_units = "kg m-3 kg s-1" ; endif
 
  allocate(cs%tr(isd:ied,jsd:jed,nz,cs%ntr)) ; cs%tr(:,:,:,:) = 0.0
 
  do m=1,cs%ntr
    ! This is needed to force the compiler not to do a copy in the registration
    ! calls.  Curses on the designers and implementers of Fortran90.
    tr_ptr => cs%tr(:,:,:,m)
    call query_vardesc(cs%tr_desc(m), name=var_name, caller="register_oil_tracer")
    ! Register the tracer for horizontal advection, diffusion, and restarts.
    call register_tracer(tr_ptr, tr_reg, param_file, hi, gv, tr_desc=cs%tr_desc(m), &
                         registry_diags=.true., flux_units=flux_units, restart_cs=restart_cs, &
                         mandatory=.not.cs%oil_may_reinit)
 
    !   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_oil_tracer")
  enddo
 
  cs%tr_Reg => tr_reg
  cs%restart_CSp => restart_cs
  register_oil_tracer = .true.
 

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

Here is the call graph for this function:

Variable Documentation

ntr_max

integer, parameter oil_tracer::ntr_max = 20

private

the maximum number of tracers in this module.

Definition at line 35 of file oil_tracer.F90.

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

Referenced by register_oil_tracer().