bfb_surface_forcing Module Reference

Data Types
type	bfb_surface_forcing_cs

Functions/Subroutines
subroutine, public	bfb_buoyancy_forcing (state, fluxes, day, dt, G, CS)
subroutine	alloc_if_needed (ptr, isd, ied, jsd, jed)
subroutine, public	bfb_surface_forcing_init (Time, G, param_file, diag, CS)

Function/Subroutine Documentation

alloc_if_needed()

subroutine bfb_surface_forcing::alloc_if_needed ( real, dimension(:,:), pointer  ptr, integer  isd, integer  ied, integer  jsd, integer  jed  )

private

Definition at line 240 of file BFB_surface_forcing.F90.

Referenced by bfb_buoyancy_forcing().

  ! If ptr is not associated, this routine allocates it with the given size
  ! and zeros out its contents.  This is equivalent to safe_alloc_ptr in
  ! MOM_diag_mediator, but is here so as to be completely transparent.
  real, pointer :: ptr(:,:)
  integer :: isd, ied, jsd, jed
  if (.not.ASSOCIATED(ptr)) then
    allocate(ptr(isd:ied,jsd:jed))
    ptr(:,:) = 0.0
  endif

Here is the caller graph for this function:

bfb_buoyancy_forcing()

subroutine, public bfb_surface_forcing::bfb_buoyancy_forcing	(	type(surface), intent(inout)	state,
		type(forcing), intent(inout)	fluxes,
		type(time_type), intent(in)	day,
		real, intent(in)	dt,
		type(ocean_grid_type), intent(in)	G,
		type(bfb_surface_forcing_cs), pointer	CS
	)

Parameters

[in]	dt	The amount of time over which the fluxes apply, in s
[in]	g	The ocean's grid structure

Definition at line 89 of file BFB_surface_forcing.F90.

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

  type(surface),                 intent(inout) :: state
  type(forcing),                 intent(inout) :: fluxes
  type(time_type),               intent(in)    :: day
  real,                          intent(in)    :: dt   !< The amount of time over which
                                                       !! the fluxes apply, in s
  type(ocean_grid_type),         intent(in)    :: g    !< The ocean's grid structure
  type(bfb_surface_forcing_cs),  pointer       :: cs

!    This subroutine specifies the current surface fluxes of buoyancy or
!  temperature and fresh water.  It may also be modified to add
!  surface fluxes of user provided tracers.

!    When temperature is used, there are long list of fluxes that need to be
!  set - essentially the same as for a full coupled model, but most of these
!  can be simply set to zero.  The net fresh water flux should probably be
!  set in fluxes%evap and fluxes%lprec, with any salinity restoring
!  appearing in fluxes%vprec, and the other water flux components
!  (fprec, lrunoff and frunoff) left as arrays full of zeros.
!  Evap is usually negative and precip is usually positive.  All heat fluxes
!  are in W m-2 and positive for heat going into the ocean.  All fresh water
!  fluxes are in kg m-2 s-1 and positive for water moving into the ocean.

! Arguments: state - A structure containing fields that describe the
!                    surface state of the ocean.
!  (out)     fluxes - A structure containing pointers to any possible
!                     forcing fields.  Unused fields have NULL ptrs.
!  (in)      day_start - Start time of the fluxes.
!  (in)      day_interval - Length of time over which these fluxes
!                           will be applied.
!  (in)      G - The ocean's grid structure.
!  (in)      CS - A pointer to the control structure returned by a previous
!                 call to user_surface_forcing_init

  real :: temp_restore   ! The temperature that is being restored toward, in C.
  real :: salin_restore  ! The salinity that is being restored toward, in PSU.
  real :: density_restore  ! The potential density that is being restored
                         ! toward, in kg m-3.
  real :: rhoxcp ! The mean density times the heat capacity, in J m-3 K-1.
  real :: buoy_rest_const  ! A constant relating density anomalies to the
                           ! restoring buoyancy flux, in m5 s-3 kg-1.
  integer :: i, j, is, ie, js, je
  integer :: 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

  !   When modifying the code, comment out this error message.  It is here
  ! so that the original (unmodified) version is not accidentally used.
  ! call MOM_error(FATAL, "User_buoyancy_surface_forcing: " // &
  !   "User forcing routine called without modification." )

  ! Allocate and zero out the forcing arrays, as necessary.  This portion is
  ! usually not changed.
  if (cs%use_temperature) then
    call alloc_if_needed(fluxes%evap, isd, ied, jsd, jed)
    call alloc_if_needed(fluxes%lprec, isd, ied, jsd, jed)
    call alloc_if_needed(fluxes%fprec, isd, ied, jsd, jed)
    call alloc_if_needed(fluxes%lrunoff, isd, ied, jsd, jed)
    call alloc_if_needed(fluxes%frunoff, isd, ied, jsd, jed)
    call alloc_if_needed(fluxes%vprec, isd, ied, jsd, jed)

    call alloc_if_needed(fluxes%sw, isd, ied, jsd, jed)
    call alloc_if_needed(fluxes%lw, isd, ied, jsd, jed)
    call alloc_if_needed(fluxes%latent, isd, ied, jsd, jed)
    call alloc_if_needed(fluxes%sens, isd, ied, jsd, jed)
  else ! This is the buoyancy only mode.
    call alloc_if_needed(fluxes%buoy, isd, ied, jsd, jed)
  endif


  ! MODIFY THE CODE IN THE FOLLOWING LOOPS TO SET THE BUOYANCY FORCING TERMS.

  if ( cs%use_temperature ) then
    ! Set whichever fluxes are to be used here.  Any fluxes that
    ! are always zero do not need to be changed here.
    do j=js,je ; do i=is,ie
      ! Fluxes of fresh water through the surface are in units of kg m-2 s-1
      ! and are positive downward - i.e. evaporation should be negative.
      fluxes%evap(i,j) = -0.0 * g%mask2dT(i,j)
      fluxes%lprec(i,j) = 0.0 * g%mask2dT(i,j)

      ! vprec will be set later, if it is needed for salinity restoring.
      fluxes%vprec(i,j) = 0.0

      !   Heat fluxes are in units of W m-2 and are positive into the ocean.
      fluxes%lw(i,j) = 0.0 * g%mask2dT(i,j)
      fluxes%latent(i,j) = 0.0 * g%mask2dT(i,j)
      fluxes%sens(i,j) = 0.0 * g%mask2dT(i,j)
      fluxes%sw(i,j) = 0.0 * g%mask2dT(i,j)
    enddo ; enddo
  else ! This is the buoyancy only mode.
    do j=js,je ; do i=is,ie
      !   fluxes%buoy is the buoyancy flux into the ocean in m2 s-3.  A positive
      ! buoyancy flux is of the same sign as heating the ocean.
      fluxes%buoy(i,j) = 0.0 * g%mask2dT(i,j)
    enddo ; enddo
  endif

  if (cs%restorebuoy) then
    if (cs%use_temperature) then
      call alloc_if_needed(fluxes%heat_added, isd, ied, jsd, jed)
      !   When modifying the code, comment out this error message.  It is here
      ! so that the original (unmodified) version is not accidentally used.
      call mom_error(fatal, "User_buoyancy_surface_forcing: " // &
        "Temperature and salinity restoring used without modification." )

      rhoxcp = cs%Rho0 * fluxes%C_p
      do j=js,je ; do i=is,ie
        !   Set Temp_restore and Salin_restore to the temperature (in C) and
        ! salinity (in PSU) that are being restored toward.
        temp_restore = 0.0
        salin_restore = 0.0

        fluxes%heat_added(i,j) = (g%mask2dT(i,j) * (rhoxcp * cs%Flux_const)) * &
            (temp_restore - state%SST(i,j))
        fluxes%vprec(i,j) = - (g%mask2dT(i,j) * (cs%Rho0*cs%Flux_const)) * &
            ((salin_restore - state%SSS(i,j)) / &
             (0.5 * (salin_restore + state%SSS(i,j))))
      enddo ; enddo
    else
      !   When modifying the code, comment out this error message.  It is here
      ! so that the original (unmodified) version is not accidentally used.
      ! call MOM_error(FATAL, "User_buoyancy_surface_forcing: " // &
      !   "Buoyancy restoring used without modification." )

      ! The -1 is because density has the opposite sign to buoyancy.
      buoy_rest_const = -1.0 * (cs%G_Earth * cs%Flux_const) / cs%Rho0
      temp_restore = 0.0
      do j=js,je ; do i=is,ie
       !   Set density_restore to an expression for the surface potential
       ! density in kg m-3 that is being restored toward.
        if (g%geoLatT(i,j) < cs%lfrslat) then
            temp_restore = cs%SST_s
        else if (g%geoLatT(i,j) > cs%lfrnlat) then
            temp_restore = cs%SST_n
        else
            temp_restore = (cs%SST_s - cs%SST_n)/(cs%lfrslat - cs%lfrnlat) * &
                    (g%geoLatT(i,j) - cs%lfrslat) + cs%SST_s
        end if

        density_restore = temp_restore*cs%drho_dt + cs%Rho0

        fluxes%buoy(i,j) = g%mask2dT(i,j) * buoy_rest_const * &
                          (density_restore - state%sfc_density(i,j))
      enddo ; enddo
    endif
  endif                                             ! end RESTOREBUOY

Here is the call graph for this function:

bfb_surface_forcing_init()

subroutine, public bfb_surface_forcing::bfb_surface_forcing_init	(	type(time_type), intent(in)	Time,
		type(ocean_grid_type), intent(in)	G,
		type(param_file_type), intent(in)	param_file,
		type(diag_ctrl), intent(in), target	diag,
		type(bfb_surface_forcing_cs), pointer	CS
	)

Parameters

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

Definition at line 252 of file BFB_surface_forcing.F90.

References mom_error_handler::mom_error().

  type(time_type),                            intent(in) :: time
  type(ocean_grid_type),                      intent(in) :: g    !< The ocean's grid structure
  type(param_file_type),                      intent(in) :: param_file !< A structure to parse for run-time parameters
  type(diag_ctrl), target,                    intent(in) :: diag
  type(bfb_surface_forcing_cs), pointer    :: cs
! Arguments: Time - The current model time.
!  (in)      G - The ocean's grid structure.
!  (in)      param_file - A structure indicating the open file to parse for
!                         model parameter values.
!  (in)      diag - A structure that is used to regulate diagnostic output.
!  (in/out)  CS - A pointer that is set to point to the control structure
!                 for this module

! This include declares and sets the variable "version".
#include "version_variable.h"
  character(len=40)  :: mdl = "BFB_surface_forcing" ! This module's name.

  if (associated(cs)) then
    call mom_error(warning, "BFB_surface_forcing_init called with an associated "// &
                             "control structure.")
    return
  endif
  allocate(cs)
  cs%diag => diag

  ! Read all relevant parameters and write them to the model log.
  call log_version(param_file, mdl, version, "")
  call get_param(param_file, mdl, "ENABLE_THERMODYNAMICS", cs%use_temperature, &
                 "If true, Temperature and salinity are used as state \n"//&
                 "variables.", default=.true.)

  call get_param(param_file, mdl, "G_EARTH", cs%G_Earth, &
                 "The gravitational acceleration of the Earth.", &
                 units="m s-2", default = 9.80)
  call get_param(param_file, mdl, "RHO_0", cs%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, "LFR_SLAT", cs%lfrslat, &
                 "Southern latitude where the linear forcing ramp begins.", &
                 units="degrees", default = 20.0)
  call get_param(param_file, mdl, "LFR_NLAT", cs%lfrnlat, &
                 "Northern latitude where the linear forcing ramp ends.", &
                 units="degrees", default = 40.0)
  call get_param(param_file, mdl, "SST_S", cs%SST_s, &
                 "SST at the southern edge of the linear forcing ramp.", &
                 units="C", default = 20.0)
  call get_param(param_file, mdl, "SST_N", cs%SST_n, &
                 "SST at the northern edge of the linear forcing ramp.", &
                 units="C", default = 10.0)
  call get_param(param_file, mdl, "DRHO_DT", cs%drho_dt, &
                 "The rate of change of density with temperature.", &
                 units="kg m-3 K-1", default = -0.2)
  call get_param(param_file, mdl, "GUST_CONST", cs%gust_const, &
                 "The background gustiness in the winds.", units="Pa", &
                 default=0.02)

  call get_param(param_file, mdl, "RESTOREBUOY", cs%restorebuoy, &
                 "If true, the buoyancy fluxes drive the model back \n"//&
                 "toward some specified surface state with a rate \n"//&
                 "given by FLUXCONST.", default= .false.)
  if (cs%restorebuoy) then
    call get_param(param_file, mdl, "FLUXCONST", cs%Flux_const, &
                 "The constant that relates the restoring surface fluxes \n"//&
                 "to the relative surface anomalies (akin to a piston \n"//&
                 "velocity).  Note the non-MKS units.", units="m day-1", &
                 fail_if_missing=.true.)
    ! Convert CS%Flux_const from m day-1 to m s-1.
    cs%Flux_const = cs%Flux_const / 86400.0
  endif

Here is the call graph for this function: