ocean_model_mod Module Reference

Data Types
interface	ocean_model_data_get
type	ocean_public_type
type	ocean_state_type

Functions/Subroutines
subroutine, public	ocean_model_init (Ocean_sfc, OS, Time_init, Time_in)
subroutine, public	update_ocean_model (Ice_ocean_boundary, OS, Ocean_sfc, time_start_update, Ocean_coupling_time_step)
subroutine	add_berg_flux_to_shelf (G, fluxes, use_ice_shelf, density_ice, kv_ice, latent_heat_fusion, state, time_step, berg_area_threshold)
subroutine, public	ocean_model_restart (OS, timestamp)
subroutine, public	ocean_model_end (Ocean_sfc, Ocean_state, Time)
subroutine, public	ocean_model_save_restart (OS, Time, directory, filename_suffix)
subroutine	initialize_ocean_public_type (input_domain, Ocean_sfc, diag, maskmap)
subroutine	convert_state_to_ocean_type (state, Ocean_sfc, G, use_conT_absS, patm, press_to_z)
subroutine, public	ocean_model_init_sfc (OS, Ocean_sfc)
subroutine, public	ocean_model_flux_init (OS)
subroutine, public	ocean_stock_pe (OS, index, value, time_index)
subroutine	ocean_model_data2d_get (OS, Ocean, name, array2D, isc, jsc)
subroutine	ocean_model_data1d_get (OS, Ocean, name, value)
subroutine, public	ocean_public_type_chksum (id, timestep, ocn)

Function/Subroutine Documentation

add_berg_flux_to_shelf()

subroutine ocean_model_mod::add_berg_flux_to_shelf ( type(ocean_grid_type), intent(inout)  G, type(forcing), intent(inout)  fluxes, logical, intent(in)  use_ice_shelf, real, intent(in)  density_ice, real, intent(in)  kv_ice, real, intent(in)  latent_heat_fusion, type(surface), intent(inout)  state, real, intent(in)  time_step, real, intent(in)  berg_area_threshold  )

private

Parameters

[in,out]

g

The ocean's grid structure

Definition at line 526 of file ocean_model_MOM.F90.

References mom_domains::to_all.

Referenced by update_ocean_model().

  type(ocean_grid_type),              intent(inout)    :: g    !< The ocean's grid structure
  type(forcing),                      intent(inout) :: fluxes
  type(surface),                      intent(inout) :: state
  logical,                            intent(in) :: use_ice_shelf
  real, intent(in) :: kv_ice       ! The viscosity of ice, in m2 s-1.
  real, intent(in) :: density_ice  ! A typical density of ice, in kg m-3.
  real, intent(in) :: latent_heat_fusion   ! The latent heat of fusion, in J kg-1.
  real, intent(in) :: time_step   ! The latent heat of fusion, in J kg-1.
  real, intent(in) :: berg_area_threshold  !Area threshold for zero'ing fluxes bellow iceberg
! Arguments:
!  (in)      fluxes - A structure of surface fluxes that may be used.
!  (in)      G - The ocean's grid structure.
  real :: fraz          ! refreezing rate in kg m-2 s-1
  integer :: i, j, is, ie, js, je, isd, ied, jsd, jed
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
  isd = g%isd ; jsd = g%jsd ; ied = g%ied ; jed = g%jed
  !This routine adds iceberg data to the ice shelf data (if ice shelf is used)
  !which can then be used to change the top of ocean boundary condition used in
  !the ocean model. This routine is taken from the add_shelf_flux subroutine
  !within the ice shelf model.

  if (.not. (((associated(fluxes%frac_shelf_h) .and. associated(fluxes%frac_shelf_u)) &
    .and.(associated(fluxes%frac_shelf_v) .and. associated(fluxes%ustar_shelf)))&
    .and.(associated(fluxes%rigidity_ice_u) .and. associated(fluxes%rigidity_ice_v)))) return

  if (.not. ((associated(fluxes%area_berg) .and.  associated(fluxes%ustar_berg)) .and. associated(fluxes%mass_berg)  ) )  return

  if (.not. use_ice_shelf) then
    fluxes%frac_shelf_h(:,:)=0.
    fluxes%frac_shelf_u(:,:)=0.
    fluxes%frac_shelf_v(:,:)=0.
    fluxes%ustar_shelf(:,:)=0.
    fluxes%rigidity_ice_u(:,:)=0.
    fluxes%rigidity_ice_v(:,:)=0.
  endif

    do j=jsd,jed ; do i=isd,ied
      if (g%areaT(i,j) > 0.0) &
        fluxes%frac_shelf_h(i,j) = fluxes%frac_shelf_h(i,j) +  fluxes%area_berg(i,j)
        fluxes%ustar_shelf(i,j)  = fluxes%ustar_shelf(i,j)  +  fluxes%ustar_berg(i,j)
    enddo ; enddo
    !do I=isd,ied-1 ; do j=isd,jed
    do j=jsd,jed ; do i=isd,ied-1 ! ### changed stride order; i->ied-1?
      fluxes%frac_shelf_u(i,j) = 0.0
      if ((g%areaT(i,j) + g%areaT(i+1,j) > 0.0)) & ! .and. (G%dxdy_u(I,j) > 0.0)) &
        fluxes%frac_shelf_u(i,j) = fluxes%frac_shelf_u(i,j) + (((fluxes%area_berg(i,j)*g%areaT(i,j)) + (fluxes%area_berg(i+1,j)*g%areaT(i+1,j))) / &
                                    (g%areaT(i,j) + g%areaT(i+1,j)))
        fluxes%rigidity_ice_u(i,j) = fluxes%rigidity_ice_u(i,j) +((kv_ice / density_ice) * &
                                    min(fluxes%mass_berg(i,j), fluxes%mass_berg(i+1,j)))
    enddo ; enddo
    do j=jsd,jed-1 ; do i=isd,ied ! ### change stride order; j->jed-1?
    !do i=isd,ied ; do J=isd,jed-1
      fluxes%frac_shelf_v(i,j) = 0.0
      if ((g%areaT(i,j) + g%areaT(i,j+1) > 0.0)) & ! .and. (G%dxdy_v(i,J) > 0.0)) &
        fluxes%frac_shelf_v(i,j) = fluxes%frac_shelf_v(i,j) + (((fluxes%area_berg(i,j)*g%areaT(i,j)) + (fluxes%area_berg(i,j+1)*g%areaT(i,j+1))) / &
                                    (g%areaT(i,j) + g%areaT(i,j+1) ))
      fluxes%rigidity_ice_v(i,j) = fluxes%rigidity_ice_v(i,j) +((kv_ice / density_ice) * &
                                   max(fluxes%mass_berg(i,j), fluxes%mass_berg(i,j+1)))
    enddo ; enddo
    call pass_vector(fluxes%frac_shelf_u, fluxes%frac_shelf_v, g%domain, to_all, cgrid_ne)

    !Zero'ing out other fluxes under the tabular icebergs
    if (berg_area_threshold >= 0.) then
      do j=jsd,jed ; do i=isd,ied
        if (fluxes%frac_shelf_h(i,j) > berg_area_threshold) then  !Only applying for ice shelf covering most of cell

          if (associated(fluxes%sw)) fluxes%sw(i,j) = 0.0
          if (associated(fluxes%lw)) fluxes%lw(i,j) = 0.0
          if (associated(fluxes%latent)) fluxes%latent(i,j) = 0.0
          if (associated(fluxes%evap)) fluxes%evap(i,j) = 0.0

          ! Add frazil formation diagnosed by the ocean model (J m-2) in the
          ! form of surface layer evaporation (kg m-2 s-1). Update lprec in the
          ! control structure for diagnostic purposes.

          if (associated(state%frazil)) then
            fraz = state%frazil(i,j) / time_step / latent_heat_fusion
            if (associated(fluxes%evap)) fluxes%evap(i,j) = fluxes%evap(i,j) - fraz
            !CS%lprec(i,j)=CS%lprec(i,j) - fraz
            state%frazil(i,j) = 0.0
          endif

          !Alon: Should these be set to zero too?
          if (associated(fluxes%sens)) fluxes%sens(i,j) = 0.0
          if (associated(fluxes%salt_flux)) fluxes%salt_flux(i,j) = 0.0
          if (associated(fluxes%lprec)) fluxes%lprec(i,j) = 0.0
        endif
      enddo ; enddo
    endif

Here is the caller graph for this function:

convert_state_to_ocean_type()

subroutine ocean_model_mod::convert_state_to_ocean_type ( type(surface), intent(inout)  state, type(ocean_public_type), intent(inout), target  Ocean_sfc, type(ocean_grid_type), intent(inout)  G, logical, intent(in)  use_conT_absS, real, dimension(:,:), intent(in), optional  patm, real, intent(in), optional  press_to_z  )

private

Parameters

[in,out]

g

The ocean's grid structure

Definition at line 758 of file ocean_model_MOM.F90.

References mom_constants::celsius_kelvin_offset.

Referenced by ocean_model_init_sfc(), and update_ocean_model().

  type(surface),           intent(inout) :: state
  type(ocean_public_type), target, intent(inout) :: ocean_sfc
  type(ocean_grid_type),   intent(inout) :: g    !< The ocean's grid structure
  logical,                 intent(in)    :: use_cont_abss
  real,          optional, intent(in)    :: patm(:,:)
  real,          optional, intent(in)    :: press_to_z
! This subroutine translates the coupler's ocean_data_type into MOM's
! surface state variable.  This may eventually be folded into the MOM
! code that calculates the surface state in the first place.
! Note the offset in the arrays because the ocean_data_type has no
! halo points in its arrays and always uses absolute indicies.
  real :: igr0
  character(len=48)  :: val_str
  integer :: isc_bnd, iec_bnd, jsc_bnd, jec_bnd
  integer :: i, j, i0, j0, is, ie, js, je

  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
  call pass_vector(state%u,state%v,g%Domain)

  call mpp_get_compute_domain(ocean_sfc%Domain, isc_bnd, iec_bnd, &
                              jsc_bnd, jec_bnd)
  if (present(patm)) then
    ! Check that the inidicies in patm are (isc_bnd:iec_bnd,jsc_bnd:jec_bnd).
    if (.not.present(press_to_z)) call mom_error(fatal, &
        'convert_state_to_ocean_type: press_to_z must be present if patm is.')
  endif

  i0 = is - isc_bnd ; j0 = js - jsc_bnd
  !If directed convert the surface T&S
  !from conservative T to potential T and
  !from absolute (reference) salinity to practical salinity
  !
  if(use_cont_abss) then
    do j=jsc_bnd,jec_bnd ; do i=isc_bnd,iec_bnd
      ocean_sfc%s_surf(i,j) = gsw_sp_from_sr(state%SSS(i+i0,j+j0))
      ocean_sfc%t_surf(i,j) = gsw_pt_from_ct(state%SSS(i+i0,j+j0),state%SST(i+i0,j+j0)) + celsius_kelvin_offset
    enddo ; enddo
  else
    do j=jsc_bnd,jec_bnd ; do i=isc_bnd,iec_bnd
      ocean_sfc%t_surf(i,j) = state%SST(i+i0,j+j0) + celsius_kelvin_offset
      ocean_sfc%s_surf(i,j) = state%SSS(i+i0,j+j0)
    enddo ; enddo
  endif

  do j=jsc_bnd,jec_bnd ; do i=isc_bnd,iec_bnd
    ocean_sfc%sea_lev(i,j) = state%sea_lev(i+i0,j+j0)
    if (present(patm)) &
      ocean_sfc%sea_lev(i,j) = ocean_sfc%sea_lev(i,j) + patm(i,j) * press_to_z
      if (associated(state%frazil)) &
      ocean_sfc%frazil(i,j) = state%frazil(i+i0,j+j0)
    ocean_sfc%area(i,j)   =  g%areaT(i+i0,j+j0)
  enddo ; enddo

  if (ocean_sfc%stagger == agrid) then
    do j=jsc_bnd,jec_bnd ; do i=isc_bnd,iec_bnd
      ocean_sfc%u_surf(i,j) = g%mask2dT(i+i0,j+j0)*0.5*(state%u(i+i0,j+j0)+state%u(i-1+i0,j+j0))
      ocean_sfc%v_surf(i,j) = g%mask2dT(i+i0,j+j0)*0.5*(state%v(i+i0,j+j0)+state%v(i+i0,j-1+j0))
    enddo ; enddo
  elseif (ocean_sfc%stagger == bgrid_ne) then
    do j=jsc_bnd,jec_bnd ; do i=isc_bnd,iec_bnd
      ocean_sfc%u_surf(i,j) = g%mask2dBu(i+i0,j+j0)*0.5*(state%u(i+i0,j+j0)+state%u(i+i0,j+j0+1))
      ocean_sfc%v_surf(i,j) = g%mask2dBu(i+i0,j+j0)*0.5*(state%v(i+i0,j+j0)+state%v(i+i0+1,j+j0))
    enddo ; enddo
  elseif (ocean_sfc%stagger == cgrid_ne) then
    do j=jsc_bnd,jec_bnd ; do i=isc_bnd,iec_bnd
      ocean_sfc%u_surf(i,j) = g%mask2dCu(i+i0,j+j0)*state%u(i+i0,j+j0)
      ocean_sfc%v_surf(i,j) = g%mask2dCv(i+i0,j+j0)*state%v(i+i0,j+j0)
    enddo ; enddo
  else
    write(val_str, '(I8)') ocean_sfc%stagger
    call mom_error(fatal, "convert_state_to_ocean_type: "//&
      "Ocean_sfc%stagger has the unrecognized value of "//trim(val_str))
  endif

  if (.not.associated(state%tr_fields,ocean_sfc%fields)) &
    call mom_error(fatal,'state%tr_fields is not pointing to Ocean_sfc%fields')

Here is the caller graph for this function:

initialize_ocean_public_type()

subroutine ocean_model_mod::initialize_ocean_public_type ( type(domain2d), intent(in)  input_domain, type(ocean_public_type), intent(inout)  Ocean_sfc, type(diag_ctrl), intent(in)  diag, logical, dimension(:,:), intent(in), optional  maskmap  )

private

Definition at line 719 of file ocean_model_MOM.F90.

Referenced by ocean_model_init().

  type(domain2d), intent(in)             :: input_domain
  type(ocean_public_type), intent(inout) :: ocean_sfc
  type(diag_ctrl), intent(in)            :: diag
  logical, intent(in), optional          :: maskmap(:,:)
  integer :: xsz, ysz, layout(2)
  ! ice-ocean-boundary fields are always allocated using absolute indicies
  ! and have no halos.
  integer :: isc_bnd, iec_bnd, jsc_bnd, jec_bnd

  call mpp_get_layout(input_domain,layout)
  call mpp_get_global_domain(input_domain, xsize=xsz, ysize=ysz)
  if(PRESENT(maskmap)) then
     call mpp_define_domains((/1,xsz,1,ysz/),layout,ocean_sfc%Domain, maskmap=maskmap)
  else
     call mpp_define_domains((/1,xsz,1,ysz/),layout,ocean_sfc%Domain)
  endif
  call mpp_get_compute_domain(ocean_sfc%Domain, isc_bnd, iec_bnd, &
                              jsc_bnd, jec_bnd)

  allocate ( ocean_sfc%t_surf (isc_bnd:iec_bnd,jsc_bnd:jec_bnd), &
             ocean_sfc%s_surf (isc_bnd:iec_bnd,jsc_bnd:jec_bnd), &
             ocean_sfc%u_surf (isc_bnd:iec_bnd,jsc_bnd:jec_bnd), &
             ocean_sfc%v_surf (isc_bnd:iec_bnd,jsc_bnd:jec_bnd), &
             ocean_sfc%sea_lev(isc_bnd:iec_bnd,jsc_bnd:jec_bnd), &
             ocean_sfc%area   (isc_bnd:iec_bnd,jsc_bnd:jec_bnd), &
             ocean_sfc%frazil (isc_bnd:iec_bnd,jsc_bnd:jec_bnd))

  ocean_sfc%t_surf  = 0.0  ! time averaged sst (Kelvin) passed to atmosphere/ice model
  ocean_sfc%s_surf  = 0.0  ! time averaged sss (psu) passed to atmosphere/ice models
  ocean_sfc%u_surf  = 0.0  ! time averaged u-current (m/sec) passed to atmosphere/ice models
  ocean_sfc%v_surf  = 0.0  ! time averaged v-current (m/sec)  passed to atmosphere/ice models
  ocean_sfc%sea_lev = 0.0  ! time averaged thickness of top model grid cell (m) plus patm/rho0/grav
  ocean_sfc%frazil  = 0.0  ! time accumulated frazil (J/m^2) passed to ice model
  ocean_sfc%area    = 0.0
  ocean_sfc%axes    = diag%axesT1%handles !diag axes to be used by coupler tracer flux diagnostics

Here is the caller graph for this function:

ocean_model_data1d_get()

subroutine ocean_model_mod::ocean_model_data1d_get	(	type(ocean_state_type), pointer	OS,
		type(ocean_public_type), intent(in)	Ocean,
		character(len=*), intent(in)	name,
		real, intent(out)	value
	)

Definition at line 1041 of file ocean_model_MOM.F90.

  type(ocean_state_type),     pointer    :: os
  type(ocean_public_type),    intent(in) :: ocean
  character(len=*)          , intent(in) :: name
  real                      , intent(out):: value

  if (.not.associated(os)) return
  if (.not.os%is_ocean_pe) return

  select case(name)
  case('c_p')
     value = os%C_p
  case default
     call mom_error(fatal,'get_ocean_grid_data1D: unknown argument name='//name)
  end select

ocean_model_data2d_get()

subroutine ocean_model_mod::ocean_model_data2d_get	(	type(ocean_state_type), pointer	OS,
		type(ocean_public_type), intent(in)	Ocean,
		character(len=*), intent(in)	name,
		real, dimension(isc:,jsc:), intent(out)	array2D,
		integer, intent(in)	isc,
		integer, intent(in)	jsc
	)

Definition at line 993 of file ocean_model_MOM.F90.

References mom_constants::celsius_kelvin_offset.

  use mom_constants, only : celsius_kelvin_offset
  type(ocean_state_type),     pointer    :: os
  type(ocean_public_type),    intent(in) :: ocean
  character(len=*)          , intent(in) :: name
  real, dimension(isc:,jsc:), intent(out):: array2d
  integer                   , intent(in) :: isc,jsc

  integer :: g_isc, g_iec, g_jsc, g_jec,g_isd, g_ied, g_jsd, g_jed, i, j

  if (.not.associated(os)) return
  if (.not.os%is_ocean_pe) return

! The problem is %areaT is on MOM domain but Ice_Ocean_Boundary%... is on mpp domain.
! We want to return the MOM data on the mpp (compute) domain
! Get MOM domain extents
  call mpp_get_compute_domain(os%grid%Domain%mpp_domain, g_isc, g_iec, g_jsc, g_jec)
  call mpp_get_data_domain   (os%grid%Domain%mpp_domain, g_isd, g_ied, g_jsd, g_jed)

  g_isc = g_isc-g_isd+1 ; g_iec = g_iec-g_isd+1 ; g_jsc = g_jsc-g_jsd+1 ; g_jec = g_jec-g_jsd+1


  select case(name)
  case('area')
     array2d(isc:,jsc:) = os%grid%areaT(g_isc:g_iec,g_jsc:g_jec)
  case('mask')
     array2d(isc:,jsc:) = os%grid%mask2dT(g_isc:g_iec,g_jsc:g_jec)
!OR same result
!     do j=g_jsc,g_jec; do i=g_isc,g_iec
!        array2D(isc+i-g_isc,jsc+j-g_jsc) = OS%grid%mask2dT(i,j)
!     enddo; enddo
  case('t_surf')
     array2d(isc:,jsc:) = ocean%t_surf(isc:,jsc:)-celsius_kelvin_offset
  case('t_pme')
     array2d(isc:,jsc:) = ocean%t_surf(isc:,jsc:)-celsius_kelvin_offset
  case('t_runoff')
     array2d(isc:,jsc:) = ocean%t_surf(isc:,jsc:)-celsius_kelvin_offset
  case('t_calving')
     array2d(isc:,jsc:) = ocean%t_surf(isc:,jsc:)-celsius_kelvin_offset
  case('btfHeat')
     array2d(isc:,jsc:) = 0
  case default
     call mom_error(fatal,'get_ocean_grid_data2D: unknown argument name='//name)
  end select

ocean_model_end()

subroutine, public ocean_model_mod::ocean_model_end	(	type(ocean_public_type), intent(inout)	Ocean_sfc,
		type(ocean_state_type), pointer	Ocean_state,
		type(time_type), intent(in)	Time
	)

Definition at line 659 of file ocean_model_MOM.F90.

References mom_diag_mediator::diag_mediator_end(), mom_ice_shelf::ice_shelf_end(), and ocean_model_save_restart().

  type(ocean_public_type),           intent(inout) :: ocean_sfc
  type(ocean_state_type),            pointer       :: ocean_state
  type(time_type),                   intent(in)    :: time

!   This subroutine terminates the model run, saving the ocean state in a
! restart file and deallocating any data associated with the ocean.

! Arguments: Ocean_sfc - An ocean_public_type structure that is to be
!                        deallocated upon termination.
!  (inout)   Ocean_state - A pointer to the structure containing the internal
!                          ocean state to be deallocated upon termination.
!  (in)      Time - The model time, used for writing restarts.

  call ocean_model_save_restart(ocean_state, time)
  call diag_mediator_end(time, ocean_state%MOM_CSp%diag)
  call mom_end(ocean_state%MOM_CSp)
  if (ocean_state%use_ice_shelf) call ice_shelf_end(ocean_state%Ice_shelf_CSp)

Here is the call graph for this function:

ocean_model_flux_init()

subroutine, public ocean_model_mod::ocean_model_flux_init

(

type(ocean_state_type), optional, pointer

OS

)

Definition at line 880 of file ocean_model_MOM.F90.

References atmos_ocean_fluxes_mod::aof_set_coupler_flux(), mom_file_parser::close_param_file(), and mom_get_input::get_mom_input().

  type(ocean_state_type), optional, pointer :: os

  integer :: dummy
  character(len=128) :: default_ice_restart_file, default_ocean_restart_file
  character(len=40)  :: mdl = "ocean_model_flux_init"  ! This module's name.
  type(param_file_type) :: param_file !< A structure to parse for run-time parameters
  type(directories) :: dirs_tmp  ! A structure containing several relevant directory paths.
  logical :: use_ocmip_cfcs, use_mom_generic_tracer
  logical :: os_is_set

  os_is_set = .false. ; if (present(os)) os_is_set = associated(os)

  call get_mom_input(param_file, dirs_tmp, check_params=.false.)

  call get_param(param_file, mdl, "USE_OCMIP2_CFC", use_ocmip_cfcs, &
                 default=.false., do_not_log=.true.)
  call get_param(param_file, mdl, "USE_generic_tracer", use_mom_generic_tracer,&
                 default=.false., do_not_log=.true.)

  call close_param_file(param_file, quiet_close=.true.)

  if(.not.os_is_set) then
    if (use_ocmip_cfcs)then
      default_ice_restart_file = 'ice_ocmip2_cfc.res.nc'
      default_ocean_restart_file = 'ocmip2_cfc.res.nc'

      dummy = aof_set_coupler_flux('cfc_11_flux', &
        flux_type = 'air_sea_gas_flux', implementation = 'ocmip2', &
        param = (/ 9.36e-07, 9.7561e-06 /), &
        ice_restart_file = default_ice_restart_file, &
        ocean_restart_file = default_ocean_restart_file,  &
        caller = "register_OCMIP2_CFC")
      dummy = aof_set_coupler_flux('cfc_12_flux', &
        flux_type = 'air_sea_gas_flux', implementation = 'ocmip2', &
        param = (/ 9.36e-07, 9.7561e-06 /), &
        ice_restart_file = default_ice_restart_file, &
        ocean_restart_file = default_ocean_restart_file, &
        caller = "register_OCMIP2_CFC")
    endif
  endif

  if (use_mom_generic_tracer) then
#ifdef _USE_GENERIC_TRACER
    call mom_generic_flux_init()
#else
    call mom_error(fatal, &
       "call_tracer_register: use_MOM_generic_tracer=.true. BUT not compiled with _USE_GENERIC_TRACER")
#endif
  endif

Here is the call graph for this function:

ocean_model_init()

subroutine, public ocean_model_mod::ocean_model_init	(	type(ocean_public_type), intent(inout), target	Ocean_sfc,
		type(ocean_state_type), pointer	OS,
		type(time_type), intent(in)	Time_init,
		type(time_type), intent(in)	Time_in
	)

Definition at line 203 of file ocean_model_MOM.F90.

References mom_forcing_type::allocate_forcing_type(), mom_error_handler::calltree_enter(), mom_error_handler::calltree_leave(), mom_file_parser::close_param_file(), mom_diag_mediator::diag_mediator_close_registration(), initialize_ocean_public_type(), mom_sum_output::mom_sum_output_init(), and mom_string_functions::uppercase().

  type(ocean_public_type), target, intent(inout) :: ocean_sfc
  type(ocean_state_type),          pointer       :: os
  type(time_type),                 intent(in)    :: time_init
  type(time_type),                 intent(in)    :: time_in
!   This subroutine initializes both the ocean state and the ocean surface type.
! Because of the way that indicies and domains are handled, Ocean_sfc must have
! been used in a previous call to initialize_ocean_type.

! Arguments: Ocean_sfc - A structure containing various publicly visible ocean
!                    surface properties after initialization, this is intent(out).
!  (out,private) OS - A structure whose internal contents are private
!                    to ocean_model_mod that may be used to contain all
!                    information about the ocean's interior state.
!  (in)      Time_init - The start time for the coupled model's calendar.
!  (in)      Time_in - The time at which to initialize the ocean model.
  real :: time_unit   ! The time unit in seconds for ENERGYSAVEDAYS.
  real :: rho0        ! The Boussinesq ocean density, in kg m-3.
  real :: g_earth     ! The gravitational acceleration in m s-2.
! This include declares and sets the variable "version".
#include "version_variable.h"
  character(len=40)  :: mdl = "ocean_model_init"  ! This module's name.
  character(len=48)  :: stagger
  integer :: secs, days
  type(param_file_type) :: param_file !< A structure to parse for run-time parameters
  logical :: offline_tracer_mode

  call calltree_enter("ocean_model_init(), ocean_model_MOM.F90")
  if (associated(os)) then
    call mom_error(warning, "ocean_model_init called with an associated "// &
                    "ocean_state_type structure. Model is already initialized.")
    return
  endif
  allocate(os)

  os%is_ocean_pe = ocean_sfc%is_ocean_pe
  if (.not.os%is_ocean_pe) return

  os%state%tr_fields => ocean_sfc%fields
  os%Time = time_in
  call initialize_mom(os%Time, param_file, os%dirs, os%MOM_CSp, time_in, &
      offline_tracer_mode=offline_tracer_mode)
  os%grid => os%MOM_CSp%G ; os%GV => os%MOM_CSp%GV
  os%C_p = os%MOM_CSp%tv%C_p
  os%fluxes%C_p = os%MOM_CSp%tv%C_p

  ! Read all relevant parameters and write them to the model log.
  call log_version(param_file, mdl, version, "")
  call get_param(param_file, mdl, "RESTART_CONTROL", os%Restart_control, &
                 "An integer whose bits encode which restart files are \n"//&
                 "written. Add 2 (bit 1) for a time-stamped file, and odd \n"//&
                 "(bit 0) for a non-time-stamped file.  A restart file \n"//&
                 "will be saved at the end of the run segment for any \n"//&
                 "non-negative value.", default=1)
  call get_param(param_file, mdl, "TIMEUNIT", time_unit, &
                 "The time unit for ENERGYSAVEDAYS.", &
                 units="s", default=86400.0)
  call get_param(param_file, mdl, "ENERGYSAVEDAYS",os%energysavedays, &
                 "The interval in units of TIMEUNIT between saves of the \n"//&
                 "energies of the run and other globally summed diagnostics.", &
                 default=set_time(0,days=1), timeunit=time_unit)

  call get_param(param_file, mdl, "OCEAN_SURFACE_STAGGER", stagger, &
                 "A case-insensitive character string to indicate the \n"//&
                 "staggering of the surface velocity field that is \n"//&
                 "returned to the coupler.  Valid values include \n"//&
                 "'A', 'B', or 'C'.", default="C")
  if (uppercase(stagger(1:1)) == 'A') then ; ocean_sfc%stagger = agrid
  elseif (uppercase(stagger(1:1)) == 'B') then ; ocean_sfc%stagger = bgrid_ne
  elseif (uppercase(stagger(1:1)) == 'C') then ; ocean_sfc%stagger = cgrid_ne
  else ; call mom_error(fatal,"ocean_model_init: OCEAN_SURFACE_STAGGER = "// &
                        trim(stagger)//" is invalid.") ; endif

  call get_param(param_file, mdl, "RESTORE_SALINITY",os%restore_salinity, &
                 "If true, the coupled driver will add a globally-balanced \n"//&
                 "fresh-water flux that drives sea-surface salinity \n"//&
                 "toward specified values.", default=.false.)
  call get_param(param_file, mdl, "RESTORE_TEMPERATURE",os%restore_temp, &
                 "If true, the coupled driver will add a  \n"//&
                 "heat flux that drives sea-surface temperauture \n"//&
                 "toward specified values.", default=.false.)
  call get_param(param_file, mdl, "RHO_0", rho0, &
                 "The mean ocean density used with BOUSSINESQ true to \n"//&
                 "calculate accelerations and the mass for conservation \n"//&
                 "properties, or with BOUSSINSEQ false to convert some \n"//&
                 "parameters from vertical units of m to kg m-2.", &
                 units="kg m-3", default=1035.0)
  call get_param(param_file, mdl, "G_EARTH", g_earth, &
                 "The gravitational acceleration of the Earth.", &
                 units="m s-2", default = 9.80)

  call get_param(param_file, mdl, "ICE_SHELF",  os%use_ice_shelf, &
                 "If true, enables the ice shelf model.", default=.false.)

  call get_param(param_file, mdl, "ICEBERGS_APPLY_RIGID_BOUNDARY",  os%icebergs_apply_rigid_boundary, &
                 "If true, allows icebergs to change boundary condition felt by ocean", default=.false.)

  if (os%icebergs_apply_rigid_boundary) then
    call get_param(param_file, mdl, "KV_ICEBERG",  os%kv_iceberg, &
                 "The viscosity of the icebergs",  units="m2 s-1",default=1.0e10)
    call get_param(param_file, mdl, "DENSITY_ICEBERGS",  os%density_iceberg, &
                  "A typical density of icebergs.", units="kg m-3", default=917.0)
    call get_param(param_file, mdl, "LATENT_HEAT_FUSION", os%latent_heat_fusion, &
                 "The latent heat of fusion.", units="J/kg", default=hlf)
    call get_param(param_file, mdl, "BERG_AREA_THRESHOLD", os%berg_area_threshold, &
                 "Fraction of grid cell which iceberg must occupy, so that fluxes \n"//&
                  "below berg are set to zero. Not applied for negative \n"//&
                 " values.", units="non-dim", default=-1.0)
  endif

  os%press_to_z = 1.0/(rho0*g_earth)

  call surface_forcing_init(time_in, os%grid, param_file, os%MOM_CSp%diag, &
                            os%forcing_CSp, os%restore_salinity, os%restore_temp)

  if (os%use_ice_shelf)  then
     call initialize_ice_shelf(param_file, os%grid, os%Time, os%ice_shelf_CSp, &
                               os%MOM_CSp%diag, os%fluxes)
  endif
  if (os%icebergs_apply_rigid_boundary)  then
    !call allocate_forcing_type(OS%grid, OS%fluxes, iceberg=.true.)
    !This assumes that the iceshelf and ocean are on the same grid. I hope this is true
    if (.not. os%use_ice_shelf) call allocate_forcing_type(os%grid, os%fluxes, ustar=.true., shelf=.true.)
  endif

  call mom_sum_output_init(os%grid, param_file, os%dirs%output_directory, &
                            os%MOM_CSp%ntrunc, time_init, os%sum_output_CSp)

  ! This call has been moved into the first call to update_ocean_model.
!  call write_energy(OS%MOM_CSp%u, OS%MOM_CSp%v, OS%MOM_CSp%h, OS%MOM_CSp%tv, &
!             OS%Time, 0, OS%grid, OS%GV, OS%sum_output_CSp, OS%MOM_CSp%tracer_flow_CSp)

  ! write_energy_time is the next integral multiple of energysavedays.
  os%write_energy_time = time_init + os%energysavedays * &
      (1 + (os%Time - time_init) / os%energysavedays)

  if(ASSOCIATED(os%grid%Domain%maskmap)) then
     call initialize_ocean_public_type(os%grid%Domain%mpp_domain, ocean_sfc, &
                                       os%MOM_CSp%diag, maskmap=os%grid%Domain%maskmap)
  else
     call initialize_ocean_public_type(os%grid%Domain%mpp_domain, ocean_sfc, &
                                       os%MOM_CSp%diag)
  endif
!  call convert_state_to_ocean_type(state, Ocean_sfc, OS%grid)

  call close_param_file(param_file)
  call diag_mediator_close_registration(os%MOM_CSp%diag)

  if (is_root_pe()) &
    write(*,'(/12x,a/)') '======== COMPLETED MOM INITIALIZATION ========'

  call calltree_leave("ocean_model_init(")

Here is the call graph for this function:

ocean_model_init_sfc()

subroutine, public ocean_model_mod::ocean_model_init_sfc	(	type(ocean_state_type), pointer	OS,
		type(ocean_public_type), intent(inout)	Ocean_sfc
	)

Definition at line 849 of file ocean_model_MOM.F90.

References convert_state_to_ocean_type().

  type(ocean_state_type),  pointer       :: os
  type(ocean_public_type), intent(inout) :: ocean_sfc

  call calculate_surface_state(os%state, os%MOM_CSp%u, &
           os%MOM_CSp%v, os%MOM_CSp%h, os%MOM_CSp%ave_ssh,&
           os%grid, os%GV, os%MOM_CSp)

  call convert_state_to_ocean_type(os%state, ocean_sfc, os%grid, os%MOM_CSp%use_conT_absS)

Here is the call graph for this function:

ocean_model_restart()

subroutine, public ocean_model_mod::ocean_model_restart	(	type(ocean_state_type), pointer	OS,
		character(len=*), intent(in), optional	timestamp
	)

Definition at line 619 of file ocean_model_MOM.F90.

References mom_surface_forcing::forcing_save_restart(), mom_ice_shelf::ice_shelf_save_restart(), and mom_restart::save_restart().

  type(ocean_state_type),        pointer :: os
  character(len=*), intent(in), optional :: timestamp

  if (os%MOM_CSp%t_dyn_rel_adv > 0.0) call mom_error(warning, "End of MOM_main reached "//&
       "with inconsistent dynamics and advective times.  Additional restart fields "//&
       "that have not been coded yet would be required for reproducibility.")
  if (.not.os%fluxes%fluxes_used) call mom_error(fatal, "ocean_model_restart "//&
      "was called with unused buoyancy fluxes.  For conservation, the ocean "//&
      "restart files can only be created after the buoyancy forcing is applied.")

  if (btest(os%Restart_control,1)) then
    call save_restart(os%dirs%restart_output_dir, os%Time, os%grid, &
                      os%MOM_CSp%restart_CSp, .true., gv=os%GV)
    call forcing_save_restart(os%forcing_CSp, os%grid, os%Time, &
                              os%dirs%restart_output_dir, .true.)
    if (os%use_ice_shelf) then
      call ice_shelf_save_restart(os%Ice_shelf_CSp, os%Time, os%dirs%restart_output_dir, .true.)
    endif
  endif
  if (btest(os%Restart_control,0)) then
    call save_restart(os%dirs%restart_output_dir, os%Time, os%grid, &
                      os%MOM_CSp%restart_CSp, gv=os%GV)
    call forcing_save_restart(os%forcing_CSp, os%grid, os%Time, &
                              os%dirs%restart_output_dir)
    if (os%use_ice_shelf) then
      call ice_shelf_save_restart(os%Ice_shelf_CSp, os%Time, os%dirs%restart_output_dir)
    endif
  endif

Here is the call graph for this function:

ocean_model_save_restart()

subroutine, public ocean_model_mod::ocean_model_save_restart	(	type(ocean_state_type), pointer	OS,
		type(time_type), intent(in)	Time,
		character(len=*), intent(in), optional	directory,
		character(len=*), intent(in), optional	filename_suffix
	)

Definition at line 681 of file ocean_model_MOM.F90.

References mom_surface_forcing::forcing_save_restart(), mom_ice_shelf::ice_shelf_save_restart(), and mom_restart::save_restart().

Referenced by ocean_model_end().

  type(ocean_state_type),     pointer    :: os
  type(time_type),            intent(in) :: time
  character(len=*), optional, intent(in) :: directory
  character(len=*), optional, intent(in) :: filename_suffix
! Arguments: Ocean_state - A structure containing the internal ocean state (in).
!  (in)      Time - The model time at this call.  This is needed for mpp_write calls.
!  (in, opt) directory - An optional directory into which to write these restart files.
!  (in, opt) filename_suffix - An optional suffix (e.g., a time-stamp) to append
!                              to the restart file names.

! Note: This is a new routine - it will need to exist for the new incremental
!   checkpointing.  It will also be called by ocean_model_end, giving the same
!   restart behavior as now in FMS.
  character(len=200) :: restart_dir

  if (os%MOM_CSp%t_dyn_rel_adv > 0.0) call mom_error(warning, "End of MOM_main reached "//&
       "with inconsistent dynamics and advective times.  Additional restart fields "//&
       "that have not been coded yet would be required for reproducibility.")
  if (.not.os%fluxes%fluxes_used) call mom_error(fatal, "ocean_model_save_restart "//&
       "was called with unused buoyancy fluxes.  For conservation, the ocean "//&
       "restart files can only be created after the buoyancy forcing is applied.")

  if (present(directory)) then ; restart_dir = directory
  else ; restart_dir = os%dirs%restart_output_dir ; endif

  call save_restart(restart_dir, time, os%grid, os%MOM_CSp%restart_CSp, gv=os%GV)

  call forcing_save_restart(os%forcing_CSp, os%grid, time, restart_dir)

  if (os%use_ice_shelf) then
     call  ice_shelf_save_restart(os%Ice_shelf_CSp, os%Time, os%dirs%restart_output_dir)
  endif

Here is the call graph for this function:

Here is the caller graph for this function:

ocean_public_type_chksum()

subroutine, public ocean_model_mod::ocean_public_type_chksum	(	character(len=*), intent(in)	id,
		integer, intent(in)	timestep,
		type(ocean_public_type), intent(in)	ocn
	)

Definition at line 1060 of file ocean_model_MOM.F90.

    character(len=*), intent(in) :: id
    integer         , intent(in) :: timestep
    type(ocean_public_type), intent(in) :: ocn
    integer ::   n,m, outunit

    outunit = stdout()

    write(outunit,*) "BEGIN CHECKSUM(ocean_type):: ", id, timestep
    write(outunit,100) 'ocean%t_surf   ',mpp_chksum(ocn%t_surf )
    write(outunit,100) 'ocean%s_surf   ',mpp_chksum(ocn%s_surf )
    write(outunit,100) 'ocean%u_surf   ',mpp_chksum(ocn%u_surf )
    write(outunit,100) 'ocean%v_surf   ',mpp_chksum(ocn%v_surf )
    write(outunit,100) 'ocean%sea_lev  ',mpp_chksum(ocn%sea_lev)
    write(outunit,100) 'ocean%frazil   ',mpp_chksum(ocn%frazil )

    do n = 1, ocn%fields%num_bcs  !{
       do m = 1, ocn%fields%bc(n)%num_fields  !{
          write(outunit,101) 'ocean%',trim(ocn%fields%bc(n)%name), &
               trim(ocn%fields%bc(n)%field(m)%name), &
               mpp_chksum(ocn%fields%bc(n)%field(m)%values)
       enddo  !} m
    enddo  !} n
101 FORMAT("   CHECKSUM::",a6,a,'%',a," = ",z20)


100 FORMAT("   CHECKSUM::",a20," = ",z20)

ocean_stock_pe()

subroutine, public ocean_model_mod::ocean_stock_pe	(	type(ocean_state_type), pointer	OS,
		integer, intent(in)	index,
		real, intent(out)	value,
		integer, intent(in), optional	time_index
	)

Definition at line 936 of file ocean_model_MOM.F90.

  use stock_constants_mod, only : istock_water, istock_heat,istock_salt
  type(ocean_state_type), pointer     :: os
  integer,                intent(in)  :: index
  real,                   intent(out) :: value
  integer,      optional, intent(in)  :: time_index
! Arguments: OS - A structure containing the internal ocean state.
!  (in)      index - Index of conservation quantity of interest.
!  (in)      value -  Sum returned for the conservation quantity of interest.
!  (in,opt)  time_index - Index for time level to use if this is necessary.

  real :: to_heat, to_mass, to_salt, psu_to_kg ! Conversion constants.
  integer :: i, j, k, is, ie, js, je, nz, ind

  value = 0.0
  if (.not.associated(os)) return
  if (.not.os%is_ocean_pe) return

  is = os%grid%isc ; ie = os%grid%iec
  js = os%grid%jsc ; je = os%grid%jec ; nz = os%grid%ke

  select case (index)
    case (istock_water)
      ! Return the mass of fresh water in the ocean on this PE in kg.
      to_mass = os%GV%H_to_kg_m2
      if (os%GV%Boussinesq) then
        do k=1,nz ; do j=js,je ; do i=is,ie ; if (os%grid%mask2dT(i,j) > 0.5) then
          value = value + to_mass*(os%MOM_CSp%h(i,j,k) * os%grid%areaT(i,j))
        endif ; enddo ; enddo ; enddo
      else
        ! In non-Boussinesq mode, the mass of salt needs to be subtracted.
        psu_to_kg = 1.0e-3
        do k=1,nz ; do j=js,je ; do i=is,ie ; if (os%grid%mask2dT(i,j) > 0.5) then
          value = value + to_mass * ((1.0 - psu_to_kg*os%MOM_CSp%tv%S(i,j,k))*&
                                  (os%MOM_CSp%h(i,j,k) * os%grid%areaT(i,j)))
        endif ; enddo ; enddo ; enddo
      endif
    case (istock_heat)
      ! Return the heat content of the ocean on this PE in J.
      to_heat = os%GV%H_to_kg_m2 * os%C_p
      do k=1,nz ; do j=js,je ; do i=is,ie ; if (os%grid%mask2dT(i,j) > 0.5) then
        value = value + (to_heat * os%MOM_CSp%tv%T(i,j,k)) * &
                        (os%MOM_CSp%h(i,j,k)*os%grid%areaT(i,j))
      endif ; enddo ; enddo ; enddo
    case (istock_salt)
      ! Return the mass of the salt in the ocean on this PE in kg.
      ! The 1000 converts salinity in PSU to salt in kg kg-1.
      to_salt = os%GV%H_to_kg_m2 / 1000.0
      do k=1,nz ; do j=js,je ; do i=is,ie ; if (os%grid%mask2dT(i,j) > 0.5) then
        value = value + (to_salt * os%MOM_CSp%tv%S(i,j,k)) * &
                        (os%MOM_CSp%h(i,j,k)*os%grid%areaT(i,j))
      endif ; enddo ; enddo ; enddo
    case default ; value = 0.0
  end select

update_ocean_model()

subroutine, public ocean_model_mod::update_ocean_model	(	type(ice_ocean_boundary_type), intent(inout)	Ice_ocean_boundary,
		type(ocean_state_type), pointer	OS,
		type(ocean_public_type), intent(inout)	Ocean_sfc,
		type(time_type), intent(in)	time_start_update,
		type(time_type), intent(in)	Ocean_coupling_time_step
	)

Definition at line 369 of file ocean_model_MOM.F90.

References add_berg_flux_to_shelf(), mom_error_handler::calltree_enter(), mom_error_handler::calltree_leave(), convert_state_to_ocean_type(), and mom::step_offline().

  type(ice_ocean_boundary_type), intent(inout) :: ice_ocean_boundary
  type(ocean_state_type),        pointer       :: os
  type(ocean_public_type),       intent(inout) :: ocean_sfc
  type(time_type), intent(in)                  :: time_start_update
  type(time_type), intent(in)                  :: ocean_coupling_time_step
!   This subroutine uses the forcing in Ice_ocean_boundary to advance the
! ocean model's state from the input value of Ocean_state (which must be for
! time time_start_update) for a time interval of Ocean_coupling_time_step,
! returning the publicly visible ocean surface properties in Ocean_sfc and
! storing the new ocean properties in Ocean_state.

! Arguments: Ice_ocean_boundary - A structure containing the various forcing
!                                 fields coming from the ice. It is intent in.
!  (inout)   Ocean_state - A structure containing the internal ocean state.
!  (out)     Ocean_sfc - A structure containing all the publicly visible ocean
!                        surface fields after a coupling time step.
!  (in)      time_start_update - The time at the beginning of the update step.
!  (in)      Ocean_coupling_time_step - The amount of time over which to advance
!                                       the ocean.

! Note: although several types are declared intent(inout), this is to allow for
!   the possibility of halo updates and to keep previously allocated memory.
!   In practice, Ice_ocean_boundary is intent in, Ocean_state is private to
!   this module and intent inout, and Ocean_sfc is intent out.
  type(time_type) :: master_time ! This allows step_MOM to temporarily change
                                 ! the time that is seen by internal modules.
  type(time_type) :: time1       ! The value of the ocean model's time at the
                                 ! start of a call to step_MOM.
  integer :: index_bnds(4)       ! The computational domain index bounds in the
                                 ! ice-ocean boundary type.
  real :: weight            ! Flux accumulation weight
  real :: time_step         ! The time step of a call to step_MOM in seconds.
  integer :: secs, days

  call calltree_enter("update_ocean_model(), ocean_model_MOM.F90")
  call get_time(ocean_coupling_time_step, secs, days)
  time_step = 86400.0*real(days) + real(secs)

  if (time_start_update /= os%Time) then
    call mom_error(warning, "update_ocean_model: internal clock does not "//&
                            "agree with time_start_update argument.")
  endif
  if (.not.associated(os)) then
    call mom_error(fatal, "update_ocean_model called with an unassociated "// &
                    "ocean_state_type structure. ocean_model_init must be "//  &
                    "called first to allocate this structure.")
    return
  endif

!  Translate Ice_ocean_boundary into fluxes.
  call mpp_get_compute_domain(ocean_sfc%Domain, index_bnds(1), index_bnds(2), &
                              index_bnds(3), index_bnds(4))

  weight = 1.0

  if (os%fluxes%fluxes_used) then
    call enable_averaging(time_step, os%Time + ocean_coupling_time_step, os%MOM_CSp%diag) ! Needed to allow diagnostics in convert_IOB
    call convert_iob_to_fluxes(ice_ocean_boundary, os%fluxes, index_bnds, os%Time, &
                               os%grid, os%forcing_CSp, os%state, os%restore_salinity,os%restore_temp)
#ifdef _USE_GENERIC_TRACER
    call mom_generic_tracer_fluxes_accumulate(os%fluxes, weight) !here weight=1, just saving the current fluxes
#endif

    ! Add ice shelf fluxes
    if (os%use_ice_shelf) then
      call shelf_calc_flux(os%State, os%fluxes, os%Time, time_step, os%Ice_shelf_CSp)
    endif
    if (os%icebergs_apply_rigid_boundary)  then
      !This assumes that the iceshelf and ocean are on the same grid. I hope this is true
      call add_berg_flux_to_shelf(os%grid, os%fluxes,os%use_ice_shelf,os%density_iceberg,os%kv_iceberg, os%latent_heat_fusion, os%State, time_step, os%berg_area_threshold)
    endif
    ! Indicate that there are new unused fluxes.
    os%fluxes%fluxes_used = .false.
    os%fluxes%dt_buoy_accum = time_step
  else
    os%flux_tmp%C_p = os%fluxes%C_p
    call convert_iob_to_fluxes(ice_ocean_boundary, os%flux_tmp, index_bnds, os%Time, &
                               os%grid, os%forcing_CSp, os%state, os%restore_salinity,os%restore_temp)
    if (os%use_ice_shelf) then
      call shelf_calc_flux(os%State, os%flux_tmp, os%Time, time_step, os%Ice_shelf_CSp)
    endif
    if (os%icebergs_apply_rigid_boundary)  then
     !This assumes that the iceshelf and ocean are on the same grid. I hope this is true
     call add_berg_flux_to_shelf(os%grid, os%flux_tmp, os%use_ice_shelf,os%density_iceberg,os%kv_iceberg, os%latent_heat_fusion, os%State, time_step, os%berg_area_threshold)
    endif

    call forcing_accumulate(os%flux_tmp, os%fluxes, time_step, os%grid, weight)
#ifdef _USE_GENERIC_TRACER
    call mom_generic_tracer_fluxes_accumulate(os%flux_tmp, weight) !weight of the current flux in the running average
#endif
  endif

  if (os%nstep==0) then
    call finish_mom_initialization(os%Time, os%dirs, os%MOM_CSp, os%fluxes)

    call write_energy(os%MOM_CSp%u, os%MOM_CSp%v, os%MOM_CSp%h, os%MOM_CSp%tv, &
                      os%Time, 0, os%grid, os%GV, os%sum_output_CSp, &
                      os%MOM_CSp%tracer_flow_CSp)
  endif

  call disable_averaging(os%MOM_CSp%diag)
  master_time = os%Time ; time1 = os%Time

  if(os%MOM_Csp%offline_tracer_mode) then
    call step_offline(os%fluxes, os%state, time1, time_step, os%MOM_CSp)
  else
    call step_mom(os%fluxes, os%state, time1, time_step, os%MOM_CSp)
  endif

  os%Time = master_time + ocean_coupling_time_step
  os%nstep = os%nstep + 1

  call enable_averaging(time_step, os%Time, os%MOM_CSp%diag)
  call mech_forcing_diags(os%fluxes, time_step, os%grid, &
                          os%MOM_CSp%diag, os%forcing_CSp%handles)
  call disable_averaging(os%MOM_CSp%diag)

  if (os%fluxes%fluxes_used) then
    call enable_averaging(os%fluxes%dt_buoy_accum, os%Time, os%MOM_CSp%diag)
    call forcing_diagnostics(os%fluxes, os%state, os%fluxes%dt_buoy_accum, &
                             os%grid, os%MOM_CSp%diag, os%forcing_CSp%handles)
    call accumulate_net_input(os%fluxes, os%state, os%fluxes%dt_buoy_accum, &
                              os%grid, os%sum_output_CSp)
    call disable_averaging(os%MOM_CSp%diag)
  endif

!  See if it is time to write out the energy.
  if ((os%Time + ((ocean_coupling_time_step)/2) > os%write_energy_time) .and. &
      (os%MOM_CSp%t_dyn_rel_adv==0.0)) then
    call write_energy(os%MOM_CSp%u, os%MOM_CSp%v, os%MOM_CSp%h, os%MOM_CSp%tv, &
                      os%Time, os%nstep, os%grid, os%GV, os%sum_output_CSp, &
                      os%MOM_CSp%tracer_flow_CSp)
    os%write_energy_time = os%write_energy_time + os%energysavedays
  endif

! Translate state into Ocean.
!  call convert_state_to_ocean_type(OS%state, Ocean_sfc, OS%grid, &
!                                   Ice_ocean_boundary%p, OS%press_to_z)
  call convert_state_to_ocean_type(os%state, ocean_sfc, os%grid, os%MOM_CSp%use_conT_absS)

  call calltree_leave("update_ocean_model()")

Here is the call graph for this function: