Data Types
type	meso_surface_forcing_cs

Functions/Subroutines
subroutine, public	meso_wind_forcing (state, fluxes, day, G, CS)

subroutine, public	meso_buoyancy_forcing (state, fluxes, day, dt, G, CS)

subroutine	alloc_if_needed (ptr, isd, ied, jsd, jed)

subroutine, public	meso_surface_forcing_init (Time, G, param_file, diag, CS)

Variables
logical	first_call = .true.

Function/Subroutine Documentation

◆ alloc_if_needed()

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

private

Definition at line 340 of file MESO_surface_forcing.F90.

Referenced by meso_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:

◆ meso_buoyancy_forcing()

subroutine, public meso_surface_forcing::meso_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(meso_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 178 of file MESO_surface_forcing.F90.

References alloc_if_needed(), first_call, 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(meso_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 MESO_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.
 
   ! 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)
     call alloc_if_needed(fluxes%heat_content_lprec, 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%restorebuoy .and. first_call) then !### .or. associated(CS%ctrl_forcing_CSp)) then
     call alloc_if_needed(cs%T_Restore, isd, ied, jsd, jed)
     call alloc_if_needed(cs%S_Restore, isd, ied, jsd, jed)
     call alloc_if_needed(cs%Heat, isd, ied, jsd, jed)
     call alloc_if_needed(cs%PmE, isd, ied, jsd, jed)
     call alloc_if_needed(cs%Solar, isd, ied, jsd, jed)
 
     call read_data(trim(cs%inputdir)//trim(cs%SSTrestore_file), "SST", &
              cs%T_Restore(:,:), domain=g%Domain%mpp_domain)
     call read_data(trim(cs%inputdir)//trim(cs%salinityrestore_file), "SAL", &
              cs%S_Restore(:,:), domain=g%Domain%mpp_domain)
     call read_data(trim(cs%inputdir)//trim(cs%heating_file), "Heat", &
              cs%Heat(:,:), domain=g%Domain%mpp_domain)
     call read_data(trim(cs%inputdir)//trim(cs%PmE_file), "PmE", &
              cs%PmE(:,:), domain=g%Domain%mpp_domain)
     call read_data(trim(cs%inputdir)//trim(cs%Solar_file), "NET_SOL", &
              cs%Solar(:,:), domain=g%Domain%mpp_domain)
     first_call = .false.
   endif
 
   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) = cs%PmE(i,j) * cs%Rho0 * 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)               = cs%Heat(i,j) * g%mask2dT(i,j)
       fluxes%sw(i,j)                 = cs%Solar(i,j) * 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, "MESO_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.
         if (g%mask2dT(i,j) > 0) then
           fluxes%heat_added(i,j) = g%mask2dT(i,j) * &
               ((cs%T_Restore(i,j) - state%SST(i,j)) * rhoxcp * cs%Flux_const)
           fluxes%vprec(i,j) = - (cs%Rho0*cs%Flux_const) * &
               (cs%S_Restore(i,j) - state%SSS(i,j)) / &
               (0.5*(state%SSS(i,j) + cs%S_Restore(i,j)))
         else
           fluxes%heat_added(i,j) = 0.0
           fluxes%vprec(i,j) = 0.0
         endif
       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, "MESO_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
       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.
         density_restore = 1030.0
 
         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:

◆ meso_surface_forcing_init()

subroutine, public meso_surface_forcing::meso_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(meso_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 352 of file MESO_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(meso_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 = "MESO_surface_forcing" ! This module's name.
 
   if (associated(cs)) then
     call mom_error(warning, "MESO_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, "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
 
     call get_param(param_file, mdl, "SSTRESTORE_FILE", cs%SSTrestore_file, &
                  "The file with the SST toward which to restore in \n"//&
                  "variable TEMP.", fail_if_missing=.true.)
     call get_param(param_file, mdl, "SALINITYRESTORE_FILE", cs%salinityrestore_file, &
                  "The file with the surface salinity toward which to \n"//&
                  "restore in variable SALT.", fail_if_missing=.true.)
     call get_param(param_file, mdl, "SENSIBLEHEAT_FILE", cs%heating_file, &
                  "The file with the non-shortwave heat flux in \n"//&
                  "variable Heat.", fail_if_missing=.true.)
     call get_param(param_file, mdl, "PRECIP_FILE", cs%PmE_file, &
                  "The file with the net precipiation minus evaporation \n"//&
                  "in variable PmE.", fail_if_missing=.true.)
     call get_param(param_file, mdl, "SHORTWAVE_FILE", cs%Solar_file, &
                  "The file with the shortwave heat flux in \n"//&
                  "variable NET_SOL.", fail_if_missing=.true.)
     call get_param(param_file, mdl, "INPUTDIR", cs%inputdir, default=".")
     cs%inputdir = slasher(cs%inputdir)
 
    endif
 

Here is the call graph for this function:

◆ meso_wind_forcing()

subroutine, public meso_surface_forcing::meso_wind_forcing	(	type(surface), intent(inout)	state,
		type(forcing), intent(inout)	fluxes,
		type(time_type), intent(in)	day,
		type(ocean_grid_type), intent(inout)	G,
		type(meso_surface_forcing_cs), pointer	CS
	)

Parameters

[in,out] g The ocean's grid structure

Definition at line 117 of file MESO_surface_forcing.F90.

References mom_forcing_type::allocate_forcing_type(), and mom_error_handler::mom_error().

   type(surface),                 intent(inout) :: state
   type(forcing),                 intent(inout) :: fluxes
   type(time_type),               intent(in)    :: day
   type(ocean_grid_type),         intent(inout) :: g    !< The ocean's grid structure
   type(meso_surface_forcing_cs), pointer       :: cs
 
 !   This subroutine sets the surface wind stresses, fluxes%taux and fluxes%tauy.
 ! These are the stresses in the direction of the model grid (i.e. the same
 ! direction as the u- and v- velocities.)  They are both in Pa.
 !   In addition, this subroutine can be used to set the surface friction
 ! velocity, fluxes%ustar, in m s-1. This is needed with a bulk mixed layer.
 !
 ! 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 - Time of the fluxes.
 !  (in)      G - The ocean's grid structure.
 !  (in)      CS - A pointer to the control structure returned by a previous
 !                 call to MESO_surface_forcing_init
 
   integer :: i, j, is, ie, js, je, isq, ieq, jsq, jeq
   integer :: isd, ied, jsd, jed, isdb, iedb, jsdb, jedb
 
   !   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, "MESO_wind_surface_forcing: " // &
      "User forcing routine called without modification." )
 
   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_forcing_type(g, fluxes, stress=.true., ustar=.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.
   do j=js,je ; do i=is-1,ieq
     fluxes%taux(i,j) = g%mask2dCu(i,j) * 0.0  ! Change this to the desired expression.
   enddo ; enddo
   do j=js-1,jeq ; do i=is,ie
     fluxes%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(fluxes%ustar)) then ; do j=js,je ; do i=is,ie
     !  This expression can be changed if desired, but need not be.
     fluxes%ustar(i,j) = g%mask2dT(i,j) * sqrt(cs%gust_const/cs%Rho0 + &
        sqrt(0.5*(fluxes%taux(i-1,j)**2 + fluxes%taux(i,j)**2) + &
             0.5*(fluxes%tauy(i,j-1)**2 + fluxes%tauy(i,j)**2))/cs%Rho0)
   enddo ; enddo ; endif
 

Here is the call graph for this function:

Variable Documentation

◆ first_call

logical meso_surface_forcing::first_call = .true.

Definition at line 112 of file MESO_surface_forcing.F90.

Referenced by meso_buoyancy_forcing().

112 logical :: first_call = .true.

Data Types

Functions/Subroutines

Variables

Function/Subroutine Documentation

◆ alloc_if_needed()

◆ meso_buoyancy_forcing()

◆ meso_surface_forcing_init()

◆ meso_wind_forcing()

Variable Documentation

◆ first_call