Detailed Description

Tidal contributions to geopotential.

Data Types
type	astro_longitudes
	Simple type to store astronomical longitudes used to calculate tidal phases. More...

type	tidal_forcing_cs
	The control structure for the MOM_tidal_forcing module. More...

Functions/Subroutines
subroutine, public	astro_longitudes_init (time_ref, longitudes)
	Finds astronomical longitudes s, h, p, and N, the mean longitude of the moon, sun, lunar perigee, and ascending node, respectively, at the specified reference time time_ref. These formulas were obtained from Kowalik and Luick, "Modern Theory and Practice of Tide Analysis and Tidal Power", 2019 (their Equation I.71), which are based on Schureman, 1958. For simplicity, the time associated with time_ref should be at midnight. These formulas also only make sense if the calendar is gregorian.

real function, public	eq_phase (constit, longitudes)
	Calculates the equilibrium phase argument for the given tidal constituent constit and the astronomical longitudes and the reference time. These formulas follow Table I.4 of Kowalik and Luick, "Modern Theory and Practice of Tide Analysis and Tidal Power", 2019.

real function, public	tidal_frequency (constit)
	Looks up angular frequencies for the main tidal constituents. Values used here are from previous versions of MOM.

subroutine, public	nodal_fu (constit, N, fn, un)
	Find amplitude (f) and phase (u) modulation of tidal constituents by the 18.6 year nodal cycle. Values here follow Table I.6 in Kowalik and Luick, "Modern Theory and Practice of Tide Analysis and Tidal Power", 2019.

subroutine, public	tidal_forcing_init (Time, G, param_file, CS)
	This subroutine allocates space for the static variables used by this module. The metrics may be effectively 0, 1, or 2-D arrays, while fields like the background viscosities are 2-D arrays. ALLOC is a macro defined in MOM_memory.h for allocate or nothing with static memory. More...

subroutine	find_in_files (filenames, varname, array, G)
	This subroutine finds a named variable in a list of files and reads its values into a domain-decomposed 2-d array. More...

subroutine, public	tidal_forcing_sensitivity (G, CS, deta_tidal_deta)
	This subroutine calculates returns the partial derivative of the local geopotential height with the input sea surface height due to self-attraction and loading. More...

subroutine, public	calc_tidal_forcing (Time, eta, eta_tidal, G, CS, deta_tidal_deta, m_to_Z)
	This subroutine calculates the geopotential anomalies that drive the tides, including self-attraction and loading. Optionally, it also returns the partial derivative of the local geopotential height with the input sea surface height. For now, eta and eta_tidal are both geopotential heights in depth units, but probably the input for eta should really be replaced with the column mass anomalies. More...

subroutine, public	tidal_forcing_end (CS)
	This subroutine deallocates memory associated with the tidal forcing module. More...

Variables
integer, parameter	max_constituents = 10
	The maximum number of tidal constituents that could be used.

integer	id_clock_tides
	CPU clock for tides.

Function/Subroutine Documentation

◆ calc_tidal_forcing()

subroutine, public mom_tidal_forcing::calc_tidal_forcing	(	type(time_type), intent(in)	Time,
		real, dimension(szi_(g),szj_(g)), intent(in)	eta,
		real, dimension(szi_(g),szj_(g)), intent(out)	eta_tidal,
		type(ocean_grid_type), intent(in)	G,
		type(tidal_forcing_cs), pointer	CS,
		real, intent(out), optional	deta_tidal_deta,
		real, intent(in), optional	m_to_Z
	)

This subroutine calculates the geopotential anomalies that drive the tides, including self-attraction and loading. Optionally, it also returns the partial derivative of the local geopotential height with the input sea surface height. For now, eta and eta_tidal are both geopotential heights in depth units, but probably the input for eta should really be replaced with the column mass anomalies.

Parameters

[in]	g	The ocean's grid structure.
[in]	time	The time for the caluculation.
[in]	eta	The sea surface height anomaly from a time-mean geoid [Z ~> m].
[out]	eta_tidal	The tidal forcing geopotential height anomalies [Z ~> m].
	cs	The control structure returned by a previous call to tidal_forcing_init.
[out]	deta_tidal_deta	The partial derivative of eta_tidal with the local value of eta [nondim].
[in]	m_to_z	A scaling factor from m to the units of eta.

Definition at line 583 of file MOM_tidal_forcing.F90.

   type(ocean_grid_type),            intent(in)  :: g         !< The ocean's grid structure.
   type(time_type),                  intent(in)  :: time      !< The time for the caluculation.
   real, dimension(SZI_(G),SZJ_(G)), intent(in)  :: eta       !< The sea surface height anomaly from
                                                              !! a time-mean geoid [Z ~> m].
   real, dimension(SZI_(G),SZJ_(G)), intent(out) :: eta_tidal !< The tidal forcing geopotential height
                                                              !! anomalies [Z ~> m].
   type(tidal_forcing_cs),           pointer     :: cs        !< The control structure returned by a
                                                              !! previous call to tidal_forcing_init.
   real, optional,                   intent(out) :: deta_tidal_deta !< The partial derivative of
                                                              !! eta_tidal with the local value of
                                                              !! eta [nondim].
   real, optional,                   intent(in)  :: m_to_z    !< A scaling factor from m to the units of eta.
 
   ! Local variables
   real :: now       ! The relative time in seconds.
   real :: amp_cosomegat, amp_sinomegat
   real :: cosomegat, sinomegat
   real :: m_z       ! A scaling factor from m to depth units.
   real :: eta_prop  ! The nondimenional constant of proportionality beteen eta and eta_tidal.
   integer :: i, j, c, m, is, ie, js, je, isq, ieq, jsq, jeq
   is = g%isc ; ie = g%iec ; js = g%jsc ; je = g%jec
   isq = g%IscB ; ieq = g%IecB ; jsq = g%JscB ; jeq = g%JecB
 
   if (.not.associated(cs)) return
 
   call cpu_clock_begin(id_clock_tides)
 
   if (cs%nc == 0) then
     do j=jsq,jeq+1 ; do i=isq,ieq+1 ; eta_tidal(i,j) = 0.0 ; enddo ; enddo
     return
   endif
 
   now = time_type_to_real(time - cs%time_ref)
 
   if (cs%USE_SAL_SCALAR .and. cs%USE_PREV_TIDES) then
     eta_prop = 2.0*cs%SAL_SCALAR
   elseif (cs%USE_SAL_SCALAR .or. cs%USE_PREV_TIDES) then
     eta_prop = cs%SAL_SCALAR
   else
     eta_prop = 0.0
   endif
 
   if (present(deta_tidal_deta)) then
     deta_tidal_deta = eta_prop
     do j=jsq,jeq+1 ; do i=isq,ieq+1 ; eta_tidal(i,j) = 0.0 ; enddo ; enddo
   else
     do j=jsq,jeq+1 ; do i=isq,ieq+1
       eta_tidal(i,j) = eta_prop*eta(i,j)
     enddo ; enddo
   endif
 
   m_z = 1.0 ; if (present(m_to_z)) m_z = m_to_z
 
   do c=1,cs%nc
     m = cs%struct(c)
     amp_cosomegat = m_z*cs%amp(c)*cs%love_no(c) * cos(cs%freq(c)*now + cs%phase0(c))
     amp_sinomegat = m_z*cs%amp(c)*cs%love_no(c) * sin(cs%freq(c)*now + cs%phase0(c))
     do j=jsq,jeq+1 ; do i=isq,ieq+1
       eta_tidal(i,j) = eta_tidal(i,j) + (amp_cosomegat*cs%cos_struct(i,j,m) + &
                                          amp_sinomegat*cs%sin_struct(i,j,m))
     enddo ; enddo
   enddo
 
   if (cs%tidal_sal_from_file) then ; do c=1,cs%nc
     cosomegat = cos(cs%freq(c)*now)
     sinomegat = sin(cs%freq(c)*now)
     do j=jsq,jeq+1 ; do i=isq,ieq+1
       eta_tidal(i,j) = eta_tidal(i,j) + m_z*cs%ampsal(i,j,c) * &
            (cosomegat*cs%cosphasesal(i,j,c) + sinomegat*cs%sinphasesal(i,j,c))
     enddo ; enddo
   enddo ; endif
 
   if (cs%USE_PREV_TIDES) then ; do c=1,cs%nc
     cosomegat = cos(cs%freq(c)*now)
     sinomegat = sin(cs%freq(c)*now)
     do j=jsq,jeq+1 ; do i=isq,ieq+1
       eta_tidal(i,j) = eta_tidal(i,j) - m_z*cs%SAL_SCALAR*cs%amp_prev(i,j,c) * &
           (cosomegat*cs%cosphase_prev(i,j,c) + sinomegat*cs%sinphase_prev(i,j,c))
     enddo ; enddo
   enddo ; endif
 
   call cpu_clock_end(id_clock_tides)
 

◆ find_in_files()

subroutine mom_tidal_forcing::find_in_files	(	character(len=*), dimension(:), intent(in)	filenames,
		character(len=*), intent(in)	varname,
		real, dimension(szi_(g),szj_(g)), intent(out)	array,
		type(ocean_grid_type), intent(in)	G
	)

private

This subroutine finds a named variable in a list of files and reads its values into a domain-decomposed 2-d array.

Parameters

[in]	filenames	The names of the files to search for the named variable
[in]	varname	The name of the variable to read
[in]	g	The ocean's grid structure
[out]	array	The array to fill with the data

Definition at line 530 of file MOM_tidal_forcing.F90.

   character(len=*), dimension(:),   intent(in)  :: filenames !< The names of the files to search for the named variable
   character(len=*),                 intent(in)  :: varname   !< The name of the variable to read
   type(ocean_grid_type),            intent(in)  :: g         !< The ocean's grid structure
   real, dimension(SZI_(G),SZJ_(G)), intent(out) :: array     !< The array to fill with the data
   ! Local variables
   integer :: nf
 
   do nf=1,size(filenames)
     if (len_trim(filenames(nf)) == 0) cycle
     if (field_exists(filenames(nf), varname, g%Domain%mpp_domain)) then
       call mom_read_data(filenames(nf), varname, array, g%Domain)
       return
     endif
   enddo
 
   do nf=size(filenames),1,-1
     if (file_exists(filenames(nf), g%Domain)) then
       call mom_error(fatal, "MOM_tidal_forcing.F90: Unable to find "// &
          trim(varname)//" in any of the tidal input files, last tried "// &
          trim(filenames(nf)))
     endif
   enddo
 
   call mom_error(fatal, "MOM_tidal_forcing.F90: Unable to find any of the "// &
                   "tidal input files, including "//trim(filenames(1)))
 

◆ tidal_forcing_end()

subroutine, public mom_tidal_forcing::tidal_forcing_end ( type(tidal_forcing_cs), pointer CS )

This subroutine deallocates memory associated with the tidal forcing module.

Parameters

cs	The control structure returned by a previous call to tidal_forcing_init; it is deallocated here.

Definition at line 670 of file MOM_tidal_forcing.F90.

   type(tidal_forcing_cs), pointer :: cs !< The control structure returned by a previous call
                                         !! to tidal_forcing_init; it is deallocated here.
 
   if (associated(cs%sin_struct)) deallocate(cs%sin_struct)
   if (associated(cs%cos_struct)) deallocate(cs%cos_struct)
 
   if (associated(cs%cosphasesal)) deallocate(cs%cosphasesal)
   if (associated(cs%sinphasesal)) deallocate(cs%sinphasesal)
   if (associated(cs%ampsal))      deallocate(cs%ampsal)
 
   if (associated(cs%cosphase_prev)) deallocate(cs%cosphase_prev)
   if (associated(cs%sinphase_prev)) deallocate(cs%sinphase_prev)
   if (associated(cs%amp_prev))      deallocate(cs%amp_prev)
 
   if (associated(cs)) deallocate(cs)
 

◆ tidal_forcing_init()

subroutine, public mom_tidal_forcing::tidal_forcing_init	(	type(time_type), intent(in)	Time,
		type(ocean_grid_type), intent(inout)	G,
		type(param_file_type), intent(in)	param_file,
		type(tidal_forcing_cs), pointer	CS
	)

This subroutine allocates space for the static variables used by this module. The metrics may be effectively 0, 1, or 2-D arrays, while fields like the background viscosities are 2-D arrays. ALLOC is a macro defined in MOM_memory.h for allocate or nothing with static memory.

Parameters

[in]	time	The current model time.
[in,out]	g	The ocean's grid structure.
[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.

Definition at line 230 of file MOM_tidal_forcing.F90.

   type(time_type),       intent(in)    :: time !< The current model time.
   type(ocean_grid_type), intent(inout) :: g    !< The ocean's grid structure.
   type(param_file_type), intent(in)    :: param_file !< A structure to parse for run-time parameters.
   type(tidal_forcing_cs), pointer      :: cs   !< A pointer that is set to point to the control
                                                !! structure for this module.
   ! Local variables
   real, dimension(SZI_(G), SZJ_(G)) :: &
     phase, &          ! The phase of some tidal constituent.
     lat_rad, lon_rad  ! Latitudes and longitudes of h-points in radians.
   real :: deg_to_rad
   real, dimension(MAX_CONSTITUENTS) :: freq_def, phase0_def, amp_def, love_def
   integer, dimension(3) :: tide_ref_date !< Reference date (t = 0) for tidal forcing.
   logical :: use_const  ! True if a constituent is being used.
   logical :: use_m2, use_s2, use_n2, use_k2, use_k1, use_o1, use_p1, use_q1
   logical :: use_mf, use_mm
   logical :: tides      ! True if a tidal forcing is to be used.
   logical :: fail_if_missing = .true.
 ! This include declares and sets the variable "version".
 #include "version_variable.h"
   character(len=40)  :: mdl = "MOM_tidal_forcing" ! This module's name.
   character(len=128) :: mesg
   character(len=200) :: tidal_input_files(4*max_constituents)
   integer :: i, j, c, is, ie, js, je, isd, ied, jsd, jed, nc
   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 (associated(cs)) then
     call mom_error(warning, "tidal_forcing_init called with an associated "// &
                             "control structure.")
     return
   endif
 
   ! Read all relevant parameters and write them to the model log.
   call log_version(param_file, mdl, version, "")
   call get_param(param_file, mdl, "TIDES", tides, &
                  "If true, apply tidal momentum forcing.", default=.false.)
 
   if (.not.tides) return
 
   allocate(cs)
 
   ! Set up the spatial structure functions for the diurnal, semidiurnal, and
   ! low-frequency tidal components.
   allocate(cs%sin_struct(isd:ied,jsd:jed,3)) ; cs%sin_struct(:,:,:) = 0.0
   allocate(cs%cos_struct(isd:ied,jsd:jed,3)) ; cs%cos_struct(:,:,:) = 0.0
   deg_to_rad = 4.0*atan(1.0)/180.0
   do j=js-1,je+1 ; do i=is-1,ie+1
     lat_rad(i,j) = g%geoLatT(i,j)*deg_to_rad
     lon_rad(i,j) = g%geoLonT(i,j)*deg_to_rad
   enddo ; enddo
   do j=js-1,je+1 ; do i=is-1,ie+1
     cs%sin_struct(i,j,1) = -sin(2.0*lat_rad(i,j)) * sin(lon_rad(i,j))
     cs%cos_struct(i,j,1) =  sin(2.0*lat_rad(i,j)) * cos(lon_rad(i,j))
     cs%sin_struct(i,j,2) = -cos(lat_rad(i,j))**2 * sin(2.0*lon_rad(i,j))
     cs%cos_struct(i,j,2) =  cos(lat_rad(i,j))**2 * cos(2.0*lon_rad(i,j))
     cs%sin_struct(i,j,3) =  0.0
     cs%cos_struct(i,j,3) = (0.5-1.5*sin(lat_rad(i,j))**2)
   enddo ; enddo
 
   call get_param(param_file, mdl, "TIDE_M2", use_m2, &
                  "If true, apply tidal momentum forcing at the M2 "//&
                  "frequency. This is only used if TIDES is true.", &
                  default=.false.)
   call get_param(param_file, mdl, "TIDE_S2", use_s2, &
                  "If true, apply tidal momentum forcing at the S2 "//&
                  "frequency. This is only used if TIDES is true.", &
                  default=.false.)
   call get_param(param_file, mdl, "TIDE_N2", use_n2, &
                  "If true, apply tidal momentum forcing at the N2 "//&
                  "frequency. This is only used if TIDES is true.", &
                  default=.false.)
   call get_param(param_file, mdl, "TIDE_K2", use_k2, &
                  "If true, apply tidal momentum forcing at the K2 "//&
                  "frequency. This is only used if TIDES is true.", &
                  default=.false.)
   call get_param(param_file, mdl, "TIDE_K1", use_k1, &
                  "If true, apply tidal momentum forcing at the K1 "//&
                  "frequency. This is only used if TIDES is true.", &
                  default=.false.)
   call get_param(param_file, mdl, "TIDE_O1", use_o1, &
                  "If true, apply tidal momentum forcing at the O1 "//&
                  "frequency. This is only used if TIDES is true.", &
                  default=.false.)
   call get_param(param_file, mdl, "TIDE_P1", use_p1, &
                  "If true, apply tidal momentum forcing at the P1 "//&
                  "frequency. This is only used if TIDES is true.", &
                  default=.false.)
   call get_param(param_file, mdl, "TIDE_Q1", use_q1, &
                  "If true, apply tidal momentum forcing at the Q1 "//&
                  "frequency. This is only used if TIDES is true.", &
                  default=.false.)
   call get_param(param_file, mdl, "TIDE_MF", use_mf, &
                  "If true, apply tidal momentum forcing at the MF "//&
                  "frequency. This is only used if TIDES is true.", &
                  default=.false.)
   call get_param(param_file, mdl, "TIDE_MM", use_mm, &
                  "If true, apply tidal momentum forcing at the MM "//&
                  "frequency. This is only used if TIDES is true.", &
                  default=.false.)
 
   ! Determine how many tidal components are to be used.
   nc = 0
   if (use_m2) nc=nc+1 ; if (use_s2) nc=nc+1
   if (use_n2) nc=nc+1 ; if (use_k2) nc=nc+1
   if (use_k1) nc=nc+1 ; if (use_o1) nc=nc+1
   if (use_p1) nc=nc+1 ; if (use_q1) nc=nc+1
   if (use_mf) nc=nc+1 ; if (use_mm) nc=nc+1
   cs%nc = nc
 
   if (nc == 0) then
     call mom_error(fatal, "tidal_forcing_init: "// &
         "TIDES are defined, but no tidal constituents are used.")
     return
   endif
 
   call get_param(param_file, mdl, "TIDAL_SAL_FROM_FILE", cs%tidal_sal_from_file, &
                  "If true, read the tidal self-attraction and loading "//&
                  "from input files, specified by TIDAL_INPUT_FILE. "//&
                  "This is only used if TIDES is true.", default=.false.)
   call get_param(param_file, mdl, "USE_PREVIOUS_TIDES", cs%use_prev_tides, &
                  "If true, use the SAL from the previous iteration of the "//&
                  "tides to facilitate convergent iteration. "//&
                  "This is only used if TIDES is true.", default=.false.)
   call get_param(param_file, mdl, "TIDE_USE_SAL_SCALAR", cs%use_sal_scalar, &
                  "If true and TIDES is true, use the scalar approximation "//&
                  "when calculating self-attraction and loading.", &
                  default=.not.cs%tidal_sal_from_file)
   ! If it is being used, sal_scalar MUST be specified in param_file.
   if (cs%use_sal_scalar .or. cs%use_prev_tides) &
     call get_param(param_file, mdl, "TIDE_SAL_SCALAR_VALUE", cs%sal_scalar, &
                  "The constant of proportionality between sea surface "//&
                  "height (really it should be bottom pressure) anomalies "//&
                  "and bottom geopotential anomalies. This is only used if "//&
                  "TIDES and TIDE_USE_SAL_SCALAR are true.", units="m m-1", &
                  fail_if_missing=.true.)
 
   if (nc > max_constituents) then
     write(mesg,'("Increase MAX_CONSTITUENTS in MOM_tidal_forcing.F90 to at least",I3, &
                 &"to accommodate all the registered tidal constituents.")') nc
     call mom_error(fatal, "MOM_tidal_forcing"//mesg)
   endif
 
   do c=1,4*max_constituents ; tidal_input_files(c) = "" ; enddo
 
   if (cs%tidal_sal_from_file .or. cs%use_prev_tides) then
     call get_param(param_file, mdl, "TIDAL_INPUT_FILE", tidal_input_files, &
                    "A list of input files for tidal information.",         &
                    default = "", fail_if_missing=.true.)
   endif
 
   call get_param(param_file, mdl, "TIDE_REF_DATE", tide_ref_date, &
                  "Year,month,day to use as reference date for tidal forcing. "//&
                  "If not specified, defaults to 0.", &
                  default=0)
 
   call get_param(param_file, mdl, "TIDE_USE_EQ_PHASE", cs%use_eq_phase, &
                  "Correct phases by calculating equilibrium phase arguments for TIDE_REF_DATE. ", &
                  default=.false., fail_if_missing=.false.)
 
   if (sum(tide_ref_date) == 0) then  ! tide_ref_date defaults to 0.
     cs%time_ref = set_date(1, 1, 1)
   else
     if(.not. cs%use_eq_phase) then
       ! Using a reference date but not using phase relative to equilibrium.
       ! This makes sense as long as either phases are overridden, or
       ! correctly simulating tidal phases is not desired.
       call mom_mesg('Tidal phases will *not* be corrected with equilibrium arguments.')
     endif
     cs%time_ref = set_date(tide_ref_date(1), tide_ref_date(2), tide_ref_date(3))
   endif
   ! Set the parameters for all components that are in use.
   ! Initialize reference time for tides and
   ! find relevant lunar and solar longitudes at the reference time.
   if (cs%use_eq_phase) call astro_longitudes_init(cs%time_ref, cs%tidal_longitudes)
   c=0
   if (use_m2) then
     c=c+1 ; cs%const_name(c) = "M2" ; cs%struct(c) = 2
     cs%love_no(c) = 0.693 ; cs%amp(c) = 0.242334
   endif
 
   if (use_s2) then
     c=c+1 ; cs%const_name(c) = "S2" ; cs%struct(c) = 2
     cs%love_no(c) = 0.693 ; cs%amp(c) = 0.112743
   endif
 
   if (use_n2) then
     c=c+1 ; cs%const_name(c) = "N2" ; cs%struct(c) = 2
     cs%love_no(c) = 0.693 ; cs%amp(c) = 0.046397
   endif
 
   if (use_k2) then
     c=c+1 ; cs%const_name(c) = "K2" ; cs%struct(c) = 2
     cs%love_no(c) = 0.693 ; cs%amp(c) = 0.030684
   endif
 
   if (use_k1) then
     c=c+1 ; cs%const_name(c) = "K1" ; cs%struct(c) = 1
     cs%love_no(c) = 0.736 ; cs%amp(c) = 0.141565
   endif
 
   if (use_o1) then
     c=c+1 ; cs%const_name(c) = "O1" ; cs%struct(c) = 1
     cs%love_no(c) = 0.695 ; cs%amp(c) = 0.100661
   endif
 
   if (use_p1) then
     c=c+1 ; cs%const_name(c) = "P1" ; cs%struct(c) = 1
     cs%love_no(c) = 0.706 ; cs%amp(c) = 0.046848
   endif
 
   if (use_q1) then
     c=c+1 ; cs%const_name(c) = "Q1" ; cs%struct(c) = 1
     cs%love_no(c) = 0.695 ; cs%amp(c) = 0.019273
   endif
 
   if (use_mf) then
     c=c+1 ; cs%const_name(c) = "MF" ; cs%struct(c) = 3
     cs%love_no(c) = 0.693 ; cs%amp(c) = 0.042041
   endif
 
   if (use_mm) then
     c=c+1 ; cs%const_name(c) = "MM" ; cs%struct(c) = 3
     cs%love_no(c) = 0.693 ; cs%amp(c) = 0.022191
   endif
 
   ! Set defaults for all included constituents
   ! and things that can be set by functions
   do c=1,nc
     cs%freq(c) = tidal_frequency(cs%const_name(c))
     freq_def(c) = cs%freq(c)
     love_def(c) = cs%love_no(c)
     amp_def(c) = cs%amp(c)
     cs%phase0(c) = 0.0
     if (cs%use_eq_phase) then
       phase0_def(c) = eq_phase(cs%const_name(c), cs%tidal_longitudes)
     else
       phase0_def(c) = 0.0
     endif
   enddo
 
   !  Parse the input file to potentially override the default values for the
   ! frequency, amplitude and initial phase of each constituent, and log the
   ! values that are actually used.
   do c=1,nc
     call get_param(param_file, mdl, "TIDE_"//trim(cs%const_name(c))//"_FREQ", cs%freq(c), &
                    "Frequency of the "//trim(cs%const_name(c))//" tidal constituent. "//&
                    "This is only used if TIDES and TIDE_"//trim(cs%const_name(c))// &
                    " are true, or if OBC_TIDE_N_CONSTITUENTS > 0 and "//trim(cs%const_name(c))// &
                    " is in OBC_TIDE_CONSTITUENTS.", units="s-1", default=freq_def(c))
     call get_param(param_file, mdl, "TIDE_"//trim(cs%const_name(c))//"_AMP", cs%amp(c), &
                    "Amplitude of the "//trim(cs%const_name(c))//" tidal constituent. "//&
                    "This is only used if TIDES and TIDE_"//trim(cs%const_name(c))// &
                    " are true.", units="m", default=amp_def(c))
     call get_param(param_file, mdl, "TIDE_"//trim(cs%const_name(c))//"_PHASE_T0", cs%phase0(c), &
                    "Phase of the "//trim(cs%const_name(c))//" tidal constituent at time 0. "//&
                    "This is only used if TIDES and TIDE_"//trim(cs%const_name(c))// &
                    " are true.", units="radians", default=phase0_def(c))
   enddo
 
   if (cs%tidal_sal_from_file) then
     allocate(cs%cosphasesal(isd:ied,jsd:jed,nc))
     allocate(cs%sinphasesal(isd:ied,jsd:jed,nc))
     allocate(cs%ampsal(isd:ied,jsd:jed,nc))
     do c=1,nc
       ! Read variables with names like PHASE_SAL_M2 and AMP_SAL_M2.
       call find_in_files(tidal_input_files,"PHASE_SAL_"//trim(cs%const_name(c)),phase,g)
       call find_in_files(tidal_input_files,"AMP_SAL_"//trim(cs%const_name(c)),cs%ampsal(:,:,c),g)
       call pass_var(phase,           g%domain,complete=.false.)
       call pass_var(cs%ampsal(:,:,c),g%domain,complete=.true.)
       do j=js-1,je+1 ; do i=is-1,ie+1
         cs%cosphasesal(i,j,c) = cos(phase(i,j)*deg_to_rad)
         cs%sinphasesal(i,j,c) = sin(phase(i,j)*deg_to_rad)
       enddo ; enddo
     enddo
   endif
 
   if (cs%USE_PREV_TIDES) then
     allocate(cs%cosphase_prev(isd:ied,jsd:jed,nc))
     allocate(cs%sinphase_prev(isd:ied,jsd:jed,nc))
     allocate(cs%amp_prev(isd:ied,jsd:jed,nc))
     do c=1,nc
       ! Read variables with names like PHASE_PREV_M2 and AMP_PREV_M2.
       call find_in_files(tidal_input_files,"PHASE_PREV_"//trim(cs%const_name(c)),phase,g)
       call find_in_files(tidal_input_files,"AMP_PREV_"//trim(cs%const_name(c)),cs%amp_prev(:,:,c),g)
       call pass_var(phase,             g%domain,complete=.false.)
       call pass_var(cs%amp_prev(:,:,c),g%domain,complete=.true.)
       do j=js-1,je+1 ; do i=is-1,ie+1
         cs%cosphase_prev(i,j,c) = cos(phase(i,j)*deg_to_rad)
         cs%sinphase_prev(i,j,c) = sin(phase(i,j)*deg_to_rad)
       enddo ; enddo
     enddo
   endif
 
   id_clock_tides = cpu_clock_id('(Ocean tides)', grain=clock_module)
 

◆ tidal_forcing_sensitivity()

subroutine, public mom_tidal_forcing::tidal_forcing_sensitivity	(	type(ocean_grid_type), intent(in)	G,
		type(tidal_forcing_cs), pointer	CS,
		real, intent(out)	deta_tidal_deta
	)

This subroutine calculates returns the partial derivative of the local geopotential height with the input sea surface height due to self-attraction and loading.

Parameters

[in]	g	The ocean's grid structure.
	cs	The control structure returned by a previous call to tidal_forcing_init.
[out]	deta_tidal_deta	The partial derivative of eta_tidal with the local value of eta [nondim].

Definition at line 562 of file MOM_tidal_forcing.F90.

   type(ocean_grid_type),  intent(in)  :: g  !< The ocean's grid structure.
   type(tidal_forcing_cs), pointer     :: cs !< The control structure returned by a previous call to tidal_forcing_init.
   real,                   intent(out) :: deta_tidal_deta !< The partial derivative of eta_tidal with
                                             !! the local value of eta [nondim].
 
   if (cs%USE_SAL_SCALAR .and. cs%USE_PREV_TIDES) then
     deta_tidal_deta = 2.0*cs%SAL_SCALAR
   elseif (cs%USE_SAL_SCALAR .or. cs%USE_PREV_TIDES) then
     deta_tidal_deta = cs%SAL_SCALAR
   else
     deta_tidal_deta = 0.0
   endif

Detailed Description

Data Types

Functions/Subroutines

Variables

Function/Subroutine Documentation

◆ calc_tidal_forcing()

◆ find_in_files()

◆ tidal_forcing_end()

◆ tidal_forcing_init()

◆ tidal_forcing_sensitivity()