neverland_surface_forcing Module Reference

Detailed Description

Wind and buoyancy forcing for the Neverland configurations.

Data Types
type	neverland_surface_forcing_cs
	This control structure should be used to store any run-time variables associated with the Neverland forcing. More...

Functions/Subroutines
subroutine, public	neverland_wind_forcing (sfc_state, forces, day, G, US, CS)
	Sets the surface wind stresses, forcestaux and forcestauy for the Neverland forcing configuration. More...
real function	cosbell (x, L)
	Returns the value of a cosine-bell function evaluated at x/L. More...
real function	spike (x, L)
	Returns the value of a sin-spike function evaluated at x/L. More...
subroutine, public	neverland_buoyancy_forcing (sfc_state, fluxes, day, dt, G, US, CS)
	Surface fluxes of buoyancy for the Neverland configurations. More...
subroutine, public	neverland_surface_forcing_init (Time, G, US, param_file, diag, CS)
	Initializes the Neverland control structure. More...

Function/Subroutine Documentation

cosbell()

real function neverland_surface_forcing::cosbell ( real, intent(in)  x, real, intent(in)  L  )

private

Returns the value of a cosine-bell function evaluated at x/L.

Parameters

[in]	x	non-dimensional position
[in]	l	non-dimensional width

Definition at line 117 of file Neverland_surface_forcing.F90.

 
  real , intent(in) :: x       !< non-dimensional position
  real , intent(in) :: L       !< non-dimensional width
  real              :: PI      !< 3.1415926... calculated as 4*atan(1)
 
  pi      = 4.0*atan(1.0)
  cosbell = 0.5 * (1 + cos(pi*min(abs(x/l),1.0)))

neverland_buoyancy_forcing()

subroutine, public neverland_surface_forcing::neverland_buoyancy_forcing	(	type(surface), intent(inout)	sfc_state,
		type(forcing), intent(inout)	fluxes,
		type(time_type), intent(in)	day,
		real, intent(in)	dt,
		type(ocean_grid_type), intent(inout)	G,
		type(unit_scale_type), intent(in)	US,
		type(neverland_surface_forcing_cs), pointer	CS
	)

Surface fluxes of buoyancy for the Neverland configurations.

Parameters

[in,out]	sfc_state	A structure containing fields that describe the surface state of the ocean.
[in,out]	fluxes	Forcing fields.
[in]	day	Time used for determining the fluxes.
[in]	dt	Forcing time step (s).
[in,out]	g	Grid structure.
[in]	us	A dimensional unit scaling type
	cs	Control structure for this module.

Definition at line 140 of file Neverland_surface_forcing.F90.

  type(surface),                 intent(inout) :: sfc_state !< A structure containing fields that
                                                    !! describe the surface state of the ocean.
  type(forcing),                 intent(inout) :: fluxes !< Forcing fields.
  type(time_type),               intent(in)    :: day !< Time used for determining the fluxes.
  real,                          intent(in)    :: dt !< Forcing time step (s).
  type(ocean_grid_type),         intent(inout) :: G  !< Grid structure.
  type(unit_scale_type),         intent(in)    :: US !< A dimensional unit scaling type
  type(Neverland_surface_forcing_CS), pointer  :: CS !< Control structure for this module.
  ! Local variables
  real :: buoy_rest_const  ! A constant relating density anomalies to the
                           ! restoring buoyancy flux [L2 T-3 R-1 ~> m5 s-3 kg-1].
  real :: density_restore  ! De
  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.
 
  ! Allocate and zero out the forcing arrays, as necessary.  This portion is
  ! usually not changed.
  if (cs%use_temperature) then
    call mom_error(fatal, "Neverland_buoyancy_forcing: " // &
        "Temperature and salinity mode not coded!" )
  else
    ! This is the buoyancy only mode.
    call safe_alloc_ptr(fluxes%buoy, isd, ied, jsd, jed)
  endif
 
 
  ! MODIFY THE CODE IN THE FOLLOWING LOOPS TO SET THE BUOYANCY FORCING TERMS.
  if (cs%restorebuoy .and. cs%first_call) then
    call safe_alloc_ptr(cs%buoy_restore, isd, ied, jsd, jed)
    cs%first_call = .false.
    ! Set CS%buoy_restore(i,j) here
  endif
 
  if ( cs%use_temperature ) then
    call mom_error(fatal, "Neverland_buoyancy_surface_forcing: " // &
      "Temperature/salinity restoring not coded!" )
  else ! This is the buoyancy only mode.
    do j=js,je ; do i=is,ie
      !   fluxes%buoy is the buoyancy flux into the ocean [L2 T-3 ~> 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 mom_error(fatal, "Neverland_buoyancy_surface_forcing: " // &
        "Temperature/salinity restoring not coded!" )
    else
      !   When modifying the code, comment out this error message.  It is here
      ! so that the original (unmodified) version is not accidentally used.
 
      ! The -1 is because density has the opposite sign to buoyancy.
      buoy_rest_const = -1.0 * (cs%G_Earth * cs%Flux_const) / cs%Rho0
      do j=js,je ; do i=is,ie
       !   Set density_restore to an expression for the surface potential
       ! density [kg m-3] that is being restored toward.
        density_restore = 1030.0
 
        fluxes%buoy(i,j) = g%mask2dT(i,j) * buoy_rest_const * &
                          us%kg_m3_to_R*(density_restore - sfc_state%sfc_density(i,j))
      enddo ; enddo
    endif
  endif                                             ! end RESTOREBUOY
 

References mom_error_handler::mom_error().

Here is the call graph for this function:

neverland_surface_forcing_init()

subroutine, public neverland_surface_forcing::neverland_surface_forcing_init	(	type(time_type), intent(in)	Time,
		type(ocean_grid_type), intent(in)	G,
		type(unit_scale_type), intent(in)	US,
		type(param_file_type), intent(in)	param_file,
		type(diag_ctrl), intent(in), target	diag,
		type(neverland_surface_forcing_cs), pointer	CS
	)

Initializes the Neverland control structure.

Parameters

[in]	time	The current model time.
[in]	g	The ocean's grid structure.
[in]	us	A dimensional unit scaling type
[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.
	cs	A pointer that is set to point to the control structure for this module

Definition at line 215 of file Neverland_surface_forcing.F90.

  type(time_type),         intent(in) :: Time       !< The current model time.
  type(ocean_grid_type),   intent(in) :: G          !< The ocean's grid structure.
  type(unit_scale_type),   intent(in) :: US         !< A dimensional unit scaling type
  type(param_file_type),   intent(in) :: param_file !< A structure indicating the open file to parse for
                                                    !! model parameter values.
  type(diag_ctrl), target, intent(in) :: diag       !< A structure that is used to regulate diagnostic output.
  type(Neverland_surface_forcing_CS), pointer :: 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"
  ! Local variables
  character(len=40) :: mdl = "Neverland_surface_forcing" ! This module's name.
 
  if (associated(cs)) then
    call mom_error(warning, "Neverland_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 "//&
                 "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, scale=us%m_to_L**2*us%Z_to_m*us%T_to_s**2)
  call get_param(param_file, mdl, "RHO_0", cs%Rho0, &
                 "The mean ocean density used with BOUSSINESQ true to "//&
                 "calculate accelerations and the mass for conservation "//&
                 "properties, or with BOUSSINSEQ false to convert some "//&
                 "parameters from vertical units of m to kg m-2.", &
                 units="kg m-3", default=1035.0, scale=us%kg_m3_to_R)
! 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 "//&
                 "toward some specified surface state with a rate "//&
                 "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 "//&
                 "to the relative surface anomalies (akin to a piston "//&
                 "velocity).  Note the non-MKS units.", &
                 units="m day-1", scale=us%m_to_Z*us%T_to_s, 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
 

References mom_error_handler::mom_error().

Referenced by mom_surface_forcing::surface_forcing_init().

Here is the call graph for this function:

Here is the caller graph for this function:

neverland_wind_forcing()

subroutine, public neverland_surface_forcing::neverland_wind_forcing	(	type(surface), intent(inout)	sfc_state,
		type(mech_forcing), intent(inout)	forces,
		type(time_type), intent(in)	day,
		type(ocean_grid_type), intent(inout)	G,
		type(unit_scale_type), intent(in)	US,
		type(neverland_surface_forcing_cs), pointer	CS
	)

Sets the surface wind stresses, forcestaux and forcestauy for the Neverland forcing configuration.

Parameters

[in,out]	sfc_state	A structure containing fields that describe the surface state of the ocean.
[in,out]	forces	A structure with the driving mechanical forces
[in]	day	Time used for determining the fluxes.
[in,out]	g	Grid structure.
[in]	us	A dimensional unit scaling type
	cs	Control structure for this module.

Definition at line 50 of file Neverland_surface_forcing.F90.

  type(surface),                 intent(inout) :: sfc_state !< A structure containing fields that
                                                         !! describe the surface state of the ocean.
  type(mech_forcing),            intent(inout) :: forces !< A structure with the driving mechanical forces
  type(time_type),               intent(in)    :: day    !< Time used for determining the fluxes.
  type(ocean_grid_type),         intent(inout) :: G      !< Grid structure.
  type(unit_scale_type),         intent(in)    :: US     !< A dimensional unit scaling type
  type(Neverland_surface_forcing_CS), pointer  :: CS     !< Control structure for this module.
 
  ! Local variables
  integer :: i, j, is, ie, js, je, Isq, Ieq, Jsq, Jeq
  integer :: isd, ied, jsd, jed, IsdB, IedB, JsdB, JedB
  real :: x, y
  real :: PI
  real :: tau_max  ! The magnitude of the wind stress [R Z L T-2 ~> Pa]
  real :: off
 
  is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
  isq = g%IscB ; ieq = g%IecB ; jsq = g%JscB ; jeq = g%JecB
  isd = g%isd ; ied = g%ied ; jsd = g%jsd ; jed = g%jed
  isdb = g%IsdB ; iedb = g%IedB ; jsdb = g%JsdB ; jedb = g%JedB
 
  ! Allocate the forcing arrays, if necessary.
  call allocate_mech_forcing(g, forces, stress=.true.)
 
  !  Set the surface wind stresses, in units of Pa.  A positive taux
  !  accelerates the ocean to the (pseudo-)east.
 
  !  The i-loop extends to is-1 so that taux can be used later in the
  ! calculation of ustar - otherwise the lower bound would be Isq.
  pi = 4.0*atan(1.0)
  forces%taux(:,:) = 0.0
  tau_max = 0.2 * us%kg_m3_to_R*us%m_s_to_L_T**2*us%L_to_Z
  off = 0.02
  do j=js,je ; do i=is-1,ieq
!    x = (G%geoLonT(i,j)-G%west_lon)/G%len_lon
    y = (g%geoLatT(i,j)-g%south_lat)/g%len_lat
!    forces%taux(I,j) = G%mask2dCu(I,j) * 0.0
 
    if (y <= 0.29) then
      forces%taux(i,j) = forces%taux(i,j) + tau_max * ( (1/0.29)*y - ( 1/(2*pi) )*sin( (2*pi*y) / 0.29 ) )
    endif
    if ((y > 0.29) .and. (y <= (0.8-off))) then
      forces%taux(i,j) = forces%taux(i,j) + tau_max *(0.35+0.65*cos(pi*(y-0.29)/(0.51-off))  )
    endif
    if ((y > (0.8-off)) .and. (y <= (1-off))) then
      forces%taux(i,j) = forces%taux(i,j) + tau_max *( 1.5*( (y-1+off) - (0.1/pi)*sin(10.0*pi*(y-0.8+off)) ) )
    endif
  enddo ; enddo
 
  do j=js-1,jeq ; do i=is,ie
    forces%tauy(i,j) = g%mask2dCv(i,j) * 0.0  ! Change this to the desired expression.
  enddo ; enddo
 
  !    Set the surface friction velocity, in units of m s-1.  ustar
  !  is always positive.
! if (associated(forces%ustar)) then ; do j=js,je ; do i=is,ie
!   !  This expression can be changed if desired, but need not be.
!   forces%ustar(i,j) = G%mask2dT(i,j) * sqrt((CS%gust_const + &
!           sqrt(0.5*(forces%taux(I-1,j)**2 + forces%taux(I,j)**2) + &
!                0.5*(forces%tauy(i,J-1)**2 + forces%tauy(i,J)**2))) * &
!            (US%L_to_Z / CS%Rho0) )
! enddo ; enddo ; endif
 

References mom_forcing_type::allocate_mech_forcing().

Here is the call graph for this function:

spike()

real function neverland_surface_forcing::spike ( real, intent(in)  x, real, intent(in)  L  )

private

Returns the value of a sin-spike function evaluated at x/L.

Parameters

[in]	x	non-dimensional position
[in]	l	non-dimensional width

Definition at line 128 of file Neverland_surface_forcing.F90.

 
  real , intent(in) :: x       !< non-dimensional position
  real , intent(in) :: L       !< non-dimensional width
  real              :: PI      !< 3.1415926... calculated as 4*atan(1)
 
  pi    = 4.0*atan(1.0)
  spike = (1 - sin(pi*min(abs(x/l),0.5)))