New URL for NEMO forge! http://forge.nemo-ocean.eu

Since March 2022 along with NEMO 4.2 release, the code development moved to a self-hosted GitLab.
This present forge is now archived and remained online for history.

zdfdrg.F90 in NEMO/trunk/src/OCE/ZDF – NEMO

Context Navigation

source: NEMO/trunk/src/OCE/ZDF/zdfdrg.F90 @ 13472

Last change on this file since 13472 was 13472, checked in by smasson, 4 years ago
trunk: commit changes from r4.0-HEAD from 13284 to 13449, see #2523
Property svn:keywords set to `Id`
File size: 25.0 KB

Rev	Line
[8215]	1	MODULE zdfdrg
	2	!!======================================================================
	3	!! * MODULE zdfdrg *
	4	!! Ocean physics: top and/or Bottom friction
	5	!!======================================================================
	6	!! History : OPA ! 1997-06 (G. Madec, A.-M. Treguier) Original code
	7	!! NEMO 1.0 ! 2002-06 (G. Madec) F90: Free form and module
	8	!! 3.2 ! 2009-09 (A.C.Coward) Correction to include barotropic contribution
	9	!! 3.3 ! 2010-10 (C. Ethe, G. Madec) reorganisation of initialisation phase
	10	!! 3.4 ! 2011-11 (H. Liu) implementation of semi-implicit bottom friction option
	11	!! ! 2012-06 (H. Liu) implementation of Log Layer bottom friction option
	12	!! 4.0 ! 2017-05 (G. Madec) zdfbfr becomes zdfdrg + variable names change
	13	!! + drag defined at t-point + new user interface + top drag (ocean cavities)
	14	!!----------------------------------------------------------------------
	15
	16	!!----------------------------------------------------------------------
	17	!! zdf_drg : update bottom friction coefficient (non-linear bottom friction only)
[9250]	18	!! zdf_drg_exp : compute the top & bottom friction in explicit case
[8215]	19	!! zdf_drg_init : read in namdrg namelist and control the bottom friction parameters.
	20	!! drg_init :
	21	!!----------------------------------------------------------------------
	22	USE oce ! ocean dynamics and tracers variables
[8568]	23	USE phycst , ONLY : vkarmn
[8215]	24	USE dom_oce ! ocean space and time domain variables
	25	USE zdf_oce ! ocean vertical physics variables
[9250]	26	USE trd_oce ! trends: ocean variables
	27	USE trddyn ! trend manager: dynamics
[8215]	28	!
	29	USE in_out_manager ! I/O manager
	30	USE iom ! I/O module
	31	USE lbclnk ! ocean lateral boundary conditions (or mpp link)
	32	USE lib_mpp ! distributed memory computing
	33	USE prtctl ! Print control
[13472]	34	USE sbc_oce , ONLY : nn_ice
[8215]	35
	36	IMPLICIT NONE
	37	PRIVATE
	38
	39	PUBLIC zdf_drg ! called by zdf_phy
[9250]	40	PUBLIC zdf_drg_exp ! called by dyn_zdf
[8215]	41	PUBLIC zdf_drg_init ! called by zdf_phy_init
	42
	43	! !!* Namelist namdrg: nature of drag coefficient namelist *
[13461]	44	LOGICAL , PUBLIC :: ln_drg_OFF ! free-slip : Cd = 0
[8215]	45	LOGICAL :: ln_lin ! linear drag: Cd = Cd0_lin
	46	LOGICAL :: ln_non_lin ! non-linear drag: Cd = Cd0_nl \|U\|
	47	LOGICAL :: ln_loglayer ! logarithmic drag: Cd = vkarmn/log(z/z0)
	48	LOGICAL , PUBLIC :: ln_drgimp ! implicit top/bottom friction flag
[13472]	49	LOGICAL , PUBLIC :: ln_drgice_imp ! implicit ice-ocean drag
[8215]	50	! !!* Namelist namdrg_top & _bot: TOP or BOTTOM coefficient namelist *
	51	REAL(wp) :: rn_Cd0 !: drag coefficient [ - ]
	52	REAL(wp) :: rn_Uc0 !: characteristic velocity (linear case: tau=rhoCd0Uc0*u) [m/s]
	53	REAL(wp) :: rn_Cdmax !: drag value maximum (ln_loglayer=T) [ - ]
	54	REAL(wp) :: rn_z0 !: roughness (ln_loglayer=T) [ m ]
	55	REAL(wp) :: rn_ke0 !: background kinetic energy (non-linear case) [m2/s2]
	56	LOGICAL :: ln_boost !: =T regional boost of Cd0 ; =F Cd0 horizontally uniform
[9256]	57	REAL(wp) :: rn_boost !: local boost factor [ - ]
[8215]	58
	59	REAL(wp), PUBLIC :: r_Cdmin_top, r_Cdmax_top, r_z0_top, r_ke0_top ! set from namdrg_top namelist values
	60	REAL(wp), PUBLIC :: r_Cdmin_bot, r_Cdmax_bot, r_z0_bot, r_ke0_bot ! - - namdrg_bot - -
	61
	62	INTEGER :: ndrg ! choice of the type of drag coefficient
	63	! ! associated indices:
[9526]	64	INTEGER, PARAMETER :: np_OFF = 0 ! free-slip: drag set to zero
[8215]	65	INTEGER, PARAMETER :: np_lin = 1 ! linear drag: Cd = Cd0_lin
	66	INTEGER, PARAMETER :: np_non_lin = 2 ! non-linear drag: Cd = Cd0_nl \|U\|
	67	INTEGER, PARAMETER :: np_loglayer = 3 ! non linear drag (logarithmic formulation): Cd = vkarmn/log(z/z0)
	68
	69	LOGICAL , PUBLIC :: l_zdfdrg !: flag to update at each time step the top/bottom Cd
	70	LOGICAL :: l_log_not_linssh !: flag to update at each time step the position ot the velocity point
	71	!
	72	REAL(wp), ALLOCATABLE, SAVE, DIMENSION(:,:), PUBLIC :: rCd0_top, rCd0_bot !: precomputed top/bottom drag coeff. at t-point (>0)
	73	REAL(wp), ALLOCATABLE, SAVE, DIMENSION(:,:), PUBLIC :: rCdU_top, rCdU_bot !: top/bottom drag coeff. at t-point (<0) [m/s]
	74
	75	!! * Substitutions
[12377]	76	# include "do_loop_substitute.h90"
[13237]	77	# include "domzgr_substitute.h90"
[8215]	78	!!----------------------------------------------------------------------
[9598]	79	!! NEMO/OCE 4.0 , NEMO Consortium (2018)
[10069]	80	!! $Id$
[10068]	81	!! Software governed by the CeCILL license (see ./LICENSE)
[8215]	82	!!----------------------------------------------------------------------
	83	CONTAINS
	84
[12377]	85	SUBROUTINE zdf_drg( kt, Kmm, k_mk, pCdmin, pCdmax, pz0, pke0, pCd0, & ! <<== in
[9089]	86	& pCdU ) ! ==>> out : bottom drag [m/s]
[8215]	87	!!----------------------------------------------------------------------
	88	!! * ROUTINE zdf_drg *
	89	!!
	90	!! ** Purpose : update the top/bottom drag coefficient (non-linear case only)
	91	!!
	92	!! ** Method : In non linear friction case, the drag coeficient is
	93	!! a function of the velocity:
	94	!! Cd = cd0 * \|U+Ut\|
	95	!! where U is the top or bottom velocity and
	96	!! Ut a tidal velocity (Ut^2 = Tidal kinetic energy
	97	!! assumed here here to be constant)
	98	!! Depending on the input variable, the top- or bottom drag is compted
	99	!!
	100	!! ** Action : p_Cd drag coefficient at t-point
	101	!!----------------------------------------------------------------------
	102	INTEGER , INTENT(in ) :: kt ! ocean time-step index
[12377]	103	INTEGER , INTENT(in ) :: Kmm ! ocean time level index
[8215]	104	! ! !! !== top or bottom variables ==!
	105	INTEGER , DIMENSION(:,:), INTENT(in ) :: k_mk ! wet level (1st or last)
	106	REAL(wp) , INTENT(in ) :: pCdmin ! min drag value
	107	REAL(wp) , INTENT(in ) :: pCdmax ! max drag value
	108	REAL(wp) , INTENT(in ) :: pz0 ! roughness
	109	REAL(wp) , INTENT(in ) :: pke0 ! background tidal KE
	110	REAL(wp), DIMENSION(:,:), INTENT(in ) :: pCd0 ! masked precomputed part of Cd0
	111	REAL(wp), DIMENSION(:,:), INTENT( out) :: pCdU ! = - Cd*\|U\| (t-points) [m/s]
	112	!!
	113	INTEGER :: ji, jj ! dummy loop indices
	114	INTEGER :: imk ! local integers
	115	REAL(wp):: zzz, zut, zvt, zcd ! local scalars
	116	!!----------------------------------------------------------------------
	117	!
	118	IF( l_log_not_linssh ) THEN !== "log layer" ==! compute Cd and -Cd*\|U\|
[13295]	119	DO_2D( 0, 0, 0, 0 )
[12377]	120	imk = k_mk(ji,jj) ! ocean bottom level at t-points
	121	zut = uu(ji,jj,imk,Kmm) + uu(ji-1,jj,imk,Kmm) ! 2 x velocity at t-point
	122	zvt = vv(ji,jj,imk,Kmm) + vv(ji,jj-1,imk,Kmm)
	123	zzz = 0.5_wp * e3t(ji,jj,imk,Kmm) ! altitude below/above (top/bottom) the boundary
	124	!
[8215]	125	!!JC: possible WAD implementation should modify line below if layers vanish
[12377]	126	zcd = ( vkarmn / LOG( zzz / pz0 ) )**2
	127	zcd = pCd0(ji,jj) * MIN( MAX( pCdmin , zcd ) , pCdmax ) ! here pCd0 = mask*boost
	128	pCdU(ji,jj) = - zcd * SQRT( 0.25 * ( zutzut + zvtzvt ) + pke0 )
	129	END_2D
[8215]	130	ELSE !== standard Cd ==!
[13295]	131	DO_2D( 0, 0, 0, 0 )
[12377]	132	imk = k_mk(ji,jj) ! ocean bottom level at t-points
	133	zut = uu(ji,jj,imk,Kmm) + uu(ji-1,jj,imk,Kmm) ! 2 x velocity at t-point
	134	zvt = vv(ji,jj,imk,Kmm) + vv(ji,jj-1,imk,Kmm)
	135	! ! here pCd0 = maskboost drag
	136	pCdU(ji,jj) = - pCd0(ji,jj) * SQRT( 0.25 * ( zutzut + zvtzvt ) + pke0 )
	137	END_2D
[8215]	138	ENDIF
	139	!
[12377]	140	IF(sn_cfctl%l_prtctl) CALL prt_ctl( tab2d_1=pCdU, clinfo1=' Cd*U ')
[8215]	141	!
	142	END SUBROUTINE zdf_drg
	143
	144
[12377]	145	SUBROUTINE zdf_drg_exp( kt, Kmm, pub, pvb, pua, pva )
[9250]	146	!!----------------------------------------------------------------------
	147	!! * ROUTINE zdf_drg_exp *
	148	!!
	149	!! ** Purpose : compute and add the explicit top and bottom frictions.
	150	!!
	151	!! ** Method : in explicit case,
	152	!!
	153	!! NB: in implicit case the calculation is performed in dynzdf.F90
	154	!!
	155	!! ** Action : (pua,pva) momentum trend increased by top & bottom friction trend
	156	!!---------------------------------------------------------------------
	157	INTEGER , INTENT(in ) :: kt ! ocean time-step index
[12377]	158	INTEGER , INTENT(in ) :: Kmm ! time level indices
[9250]	159	REAL(wp), DIMENSION(jpi,jpj,jpk), INTENT(inout) :: pub, pvb ! the two components of the before velocity
	160	REAL(wp), DIMENSION(jpi,jpj,jpk), INTENT(inout) :: pua, pva ! the two components of the velocity tendency
	161	!!
	162	INTEGER :: ji, jj ! dummy loop indexes
	163	INTEGER :: ikbu, ikbv ! local integers
	164	REAL(wp) :: zm1_2dt ! local scalar
	165	REAL(wp) :: zCdu, zCdv ! - -
	166	REAL(wp), DIMENSION(:,:,:), ALLOCATABLE :: ztrdu, ztrdv
	167	!!---------------------------------------------------------------------
	168	!
[12489]	169	!!gm bug : time step is only rn_Dt (not 2 rn_Dt if euler start !)
	170	zm1_2dt = - 1._wp / ( 2._wp * rn_Dt )
[9250]	171
	172	IF( l_trddyn ) THEN ! trends: store the input trends
	173	ALLOCATE( ztrdu(jpi,jpj,jpk) , ztrdv(jpi,jpj,jpk) )
	174	ztrdu(:,:,:) = pua(:,:,:)
	175	ztrdv(:,:,:) = pva(:,:,:)
	176	ENDIF
	177
[13295]	178	DO_2D( 0, 0, 0, 0 )
[12377]	179	ikbu = mbku(ji,jj) ! deepest wet ocean u- & v-levels
	180	ikbv = mbkv(ji,jj)
	181	!
	182	! Apply stability criteria on absolute value : abs(bfr/e3) < 1/(2dt) => bfr/e3 > -1/(2dt)
	183	zCdu = 0.5*( rCdU_bot(ji+1,jj)+rCdU_bot(ji,jj) ) / e3u(ji,jj,ikbu,Kmm)
	184	zCdv = 0.5*( rCdU_bot(ji,jj+1)+rCdU_bot(ji,jj) ) / e3v(ji,jj,ikbv,Kmm)
	185	!
	186	pua(ji,jj,ikbu) = pua(ji,jj,ikbu) + MAX( zCdu , zm1_2dt ) * pub(ji,jj,ikbu)
	187	pva(ji,jj,ikbv) = pva(ji,jj,ikbv) + MAX( zCdv , zm1_2dt ) * pvb(ji,jj,ikbv)
	188	END_2D
	189	!
	190	IF( ln_isfcav ) THEN ! ocean cavities
[13295]	191	DO_2D( 0, 0, 0, 0 )
[12377]	192	ikbu = miku(ji,jj) ! first wet ocean u- & v-levels
	193	ikbv = mikv(ji,jj)
[9250]	194	!
	195	! Apply stability criteria on absolute value : abs(bfr/e3) < 1/(2dt) => bfr/e3 > -1/(2dt)
[12377]	196	zCdu = 0.5*( rCdU_top(ji+1,jj)+rCdU_top(ji,jj) ) / e3u(ji,jj,ikbu,Kmm) ! NB: Cdtop masked
	197	zCdv = 0.5*( rCdU_top(ji,jj+1)+rCdU_top(ji,jj) ) / e3v(ji,jj,ikbv,Kmm)
[9250]	198	!
	199	pua(ji,jj,ikbu) = pua(ji,jj,ikbu) + MAX( zCdu , zm1_2dt ) * pub(ji,jj,ikbu)
	200	pva(ji,jj,ikbv) = pva(ji,jj,ikbv) + MAX( zCdv , zm1_2dt ) * pvb(ji,jj,ikbv)
[12377]	201	END_2D
[9250]	202	ENDIF
	203	!
	204	IF( l_trddyn ) THEN ! trends: send trends to trddyn for further diagnostics
	205	ztrdu(:,:,:) = pua(:,:,:) - ztrdu(:,:,:)
	206	ztrdv(:,:,:) = pva(:,:,:) - ztrdv(:,:,:)
[12377]	207	CALL trd_dyn( ztrdu(:,:,:), ztrdv(:,:,:), jpdyn_bfr, kt, Kmm )
[9250]	208	DEALLOCATE( ztrdu, ztrdv )
	209	ENDIF
	210	! ! print mean trends (used for debugging)
[12377]	211	IF(sn_cfctl%l_prtctl) CALL prt_ctl( tab3d_1=pua, clinfo1=' bfr - Ua: ', mask1=umask, &
	212	& tab3d_2=pva, clinfo2= ' Va: ', mask2=vmask, clinfo3='dyn' )
[9250]	213	!
	214	END SUBROUTINE zdf_drg_exp
	215
	216
[8215]	217	SUBROUTINE zdf_drg_init
	218	!!----------------------------------------------------------------------
	219	!! * ROUTINE zdf_brg_init *
	220	!!
	221	!! ** Purpose : Initialization of the bottom friction
	222	!!
	223	!! ** Method : Read the namdrg namelist and check their consistency
	224	!! called at the first timestep (nit000)
	225	!!----------------------------------------------------------------------
	226	INTEGER :: ji, jj ! dummy loop indexes
	227	INTEGER :: ios, ioptio ! local integers
	228	!!
[13472]	229	NAMELIST/namdrg/ ln_drg_OFF, ln_lin, ln_non_lin, ln_loglayer, ln_drgimp, ln_drgice_imp
[8215]	230	!!----------------------------------------------------------------------
	231	!
	232	! !== drag nature ==!
	233	!
	234	READ ( numnam_ref, namdrg, IOSTAT = ios, ERR = 901)
[11536]	235	901 IF( ios /= 0 ) CALL ctl_nam( ios , 'namdrg in reference namelist' )
[8215]	236	READ ( numnam_cfg, namdrg, IOSTAT = ios, ERR = 902 )
[11536]	237	902 IF( ios > 0 ) CALL ctl_nam( ios , 'namdrg in configuration namelist' )
[8215]	238	IF(lwm) WRITE ( numond, namdrg )
	239	!
	240	IF(lwp) THEN
	241	WRITE(numout,*)
	242	WRITE(numout,*) 'zdf_drg_init : top and/or bottom drag setting'
	243	WRITE(numout,*) '~~~~~~~~~~~~'
	244	WRITE(numout,*) ' Namelist namdrg : top/bottom friction choices'
[13461]	245	WRITE(numout,*) ' free-slip : Cd = 0 ln_drg_OFF = ', ln_drg_OFF
[8215]	246	WRITE(numout,*) ' linear drag : Cd = Cd0 ln_lin = ', ln_lin
	247	WRITE(numout,*) ' non-linear drag: Cd = Cd0_nl \|U\| ln_non_lin = ', ln_non_lin
	248	WRITE(numout,*) ' logarithmic drag: Cd = vkarmn/log(z/z0) ln_loglayer = ', ln_loglayer
	249	WRITE(numout,*) ' implicit friction ln_drgimp = ', ln_drgimp
[13472]	250	WRITE(numout,*) ' implicit ice-ocean drag ln_drgice_imp =', ln_drgice_imp
[8215]	251	ENDIF
	252	!
	253	ioptio = 0 ! set ndrg and control check
[13461]	254	IF( ln_drg_OFF ) THEN ; ndrg = np_OFF ; ioptio = ioptio + 1 ; ENDIF
[8215]	255	IF( ln_lin ) THEN ; ndrg = np_lin ; ioptio = ioptio + 1 ; ENDIF
	256	IF( ln_non_lin ) THEN ; ndrg = np_non_lin ; ioptio = ioptio + 1 ; ENDIF
	257	IF( ln_loglayer ) THEN ; ndrg = np_loglayer ; ioptio = ioptio + 1 ; ENDIF
	258	!
	259	IF( ioptio /= 1 ) CALL ctl_stop( 'zdf_drg_init: Choose ONE type of drag coef in namdrg' )
	260	!
[13472]	261	IF ( ln_drgice_imp.AND.(.NOT.ln_drgimp) ) &
	262	& CALL ctl_stop( 'zdf_drg_init: ln_drgice_imp=T requires ln_drgimp=T' )
[8215]	263	!
[13472]	264	IF ( ln_drgice_imp.AND.( nn_ice /=2 ) ) &
	265	& CALL ctl_stop( 'zdf_drg_init: ln_drgice_imp=T requires si3' )
	266	!
[8215]	267	! !== BOTTOM drag setting ==! (applied at seafloor)
	268	!
	269	ALLOCATE( rCd0_bot(jpi,jpj), rCdU_bot(jpi,jpj) )
	270	CALL drg_init( 'BOTTOM' , mbkt , & ! <== in
	271	& r_Cdmin_bot, r_Cdmax_bot, r_z0_bot, r_ke0_bot, rCd0_bot, rCdU_bot ) ! ==> out
	272
	273	!
	274	! !== TOP drag setting ==! (applied at the top of ocean cavities)
	275	!
[13472]	276	IF( ln_isfcav.OR.ln_drgice_imp ) THEN ! Ocean cavities: top friction setting
	277	ALLOCATE( rCdU_top(jpi,jpj) )
	278	ENDIF
	279	!
	280	IF( ln_isfcav ) THEN
	281	ALLOCATE( rCd0_top(jpi,jpj))
[8215]	282	CALL drg_init( 'TOP ' , mikt , & ! <== in
[9089]	283	& r_Cdmin_top, r_Cdmax_top, r_z0_top, r_ke0_top, rCd0_top, rCdU_top ) ! ==> out
[8215]	284	ENDIF
	285	!
	286	END SUBROUTINE zdf_drg_init
	287
	288
	289	SUBROUTINE drg_init( cd_topbot, k_mk, &
	290	& pCdmin, pCdmax, pz0, pke0, pCd0, pCdU )
	291	!!----------------------------------------------------------------------
	292	!! * ROUTINE drg_init *
	293	!!
	294	!! ** Purpose : Initialization of the top/bottom friction CdO and Cd
	295	!! from namelist parameters
	296	!!----------------------------------------------------------------------
	297	CHARACTER(len=6) , INTENT(in ) :: cd_topbot ! top/ bot indicator
	298	INTEGER , DIMENSION(:,:), INTENT(in ) :: k_mk ! 1st/last wet level
	299	REAL(wp) , INTENT( out) :: pCdmin, pCdmax ! min and max drag coef. [-]
	300	REAL(wp) , INTENT( out) :: pz0 ! roughness [m]
	301	REAL(wp) , INTENT( out) :: pke0 ! background KE [m2/s2]
	302	REAL(wp), DIMENSION(:,:), INTENT( out) :: pCd0 ! masked precomputed part of the non-linear drag coefficient
[9089]	303	REAL(wp), DIMENSION(:,:), INTENT( out) :: pCdU ! minus linear drag*\|U\| at t-points [m/s]
[8215]	304	!!
	305	CHARACTER(len=40) :: cl_namdrg, cl_file, cl_varname, cl_namref, cl_namcfg ! local names
	306	INTEGER :: ji, jj ! dummy loop indexes
	307	LOGICAL :: ll_top, ll_bot ! local logical
	308	INTEGER :: ios, inum, imk ! local integers
	309	REAL(wp):: zmsk, zzz, zcd ! local scalars
	310	REAL(wp), DIMENSION(jpi,jpj) :: zmsk_boost ! 2D workspace
	311	!!
	312	NAMELIST/namdrg_top/ rn_Cd0, rn_Uc0, rn_Cdmax, rn_ke0, rn_z0, ln_boost, rn_boost
	313	NAMELIST/namdrg_bot/ rn_Cd0, rn_Uc0, rn_Cdmax, rn_ke0, rn_z0, ln_boost, rn_boost
	314	!!----------------------------------------------------------------------
	315	!
	316	! !== set TOP / BOTTOM specificities ==!
	317	ll_top = .FALSE.
	318	ll_bot = .FALSE.
	319	!
	320	SELECT CASE (cd_topbot)
	321	CASE( 'TOP ' )
	322	ll_top = .TRUE.
	323	cl_namdrg = 'namdrg_top'
	324	cl_namref = 'namdrg_top in reference namelist'
	325	cl_namcfg = 'namdrg_top in configuration namelist'
	326	cl_file = 'tfr_coef.nc'
	327	cl_varname = 'tfr_coef'
	328	CASE( 'BOTTOM' )
	329	ll_bot = .TRUE.
	330	cl_namdrg = 'namdrg_bot'
	331	cl_namref = 'namdrg_bot in reference namelist'
	332	cl_namcfg = 'namdrg_bot in configuration namelist'
	333	cl_file = 'bfr_coef.nc'
[9209]	334	cl_varname = 'bfr_coef'
[8215]	335	CASE DEFAULT
	336	CALL ctl_stop( 'drg_init: bad value for cd_topbot ' )
	337	END SELECT
	338	!
	339	! !== read namlist ==!
	340	!
	341	IF(ll_top) READ ( numnam_ref, namdrg_top, IOSTAT = ios, ERR = 901)
	342	IF(ll_bot) READ ( numnam_ref, namdrg_bot, IOSTAT = ios, ERR = 901)
[11536]	343	901 IF( ios /= 0 ) CALL ctl_nam( ios , TRIM(cl_namref) )
[8215]	344	IF(ll_top) READ ( numnam_cfg, namdrg_top, IOSTAT = ios, ERR = 902 )
	345	IF(ll_bot) READ ( numnam_cfg, namdrg_bot, IOSTAT = ios, ERR = 902 )
[11536]	346	902 IF( ios > 0 ) CALL ctl_nam( ios , TRIM(cl_namcfg) )
[8215]	347	IF(lwm .AND. ll_top) WRITE ( numond, namdrg_top )
	348	IF(lwm .AND. ll_bot) WRITE ( numond, namdrg_bot )
	349	!
	350	IF(lwp) THEN
	351	WRITE(numout,*)
	352	WRITE(numout,*) ' Namelist ',TRIM(cl_namdrg),' : set ',TRIM(cd_topbot),' friction parameters'
	353	WRITE(numout,*) ' drag coefficient rn_Cd0 = ', rn_Cd0
	354	WRITE(numout,*) ' characteristic velocity (linear case) rn_Uc0 = ', rn_Uc0, ' m/s'
	355	WRITE(numout,*) ' non-linear drag maximum rn_Cdmax = ', rn_Cdmax
	356	WRITE(numout,*) ' background kinetic energy (n-l case) rn_ke0 = ', rn_ke0
	357	WRITE(numout,*) ' bottom roughness (n-l case) rn_z0 = ', rn_z0
	358	WRITE(numout,*) ' set a regional boost of Cd0 ln_boost = ', ln_boost
	359	WRITE(numout,*) ' associated boost factor rn_boost = ', rn_boost
	360	ENDIF
	361	!
	362	! !== return some namelist parametres ==! (used in non_lin and loglayer cases)
	363	pCdmin = rn_Cd0
	364	pCdmax = rn_Cdmax
	365	pz0 = rn_z0
	366	pke0 = rn_ke0
	367	!
	368	! !== mask * boost factor ==!
	369	!
	370	IF( ln_boost ) THEN !* regional boost: boost factor = 1 + regional boost
	371	IF(lwp) WRITE(numout,*)
[9190]	372	IF(lwp) WRITE(numout,*) ' ==>>> use a regional boost read in ', TRIM(cl_file), ' file'
	373	IF(lwp) WRITE(numout,*) ' using enhancement factor of ', rn_boost
[8215]	374	! cl_varname is a coefficient in [0,1] giving where to apply the regional boost
	375	CALL iom_open ( TRIM(cl_file), inum )
[13286]	376	CALL iom_get ( inum, jpdom_global, TRIM(cl_varname), zmsk_boost, 1 )
[8215]	377	CALL iom_close( inum)
	378	zmsk_boost(:,:) = 1._wp + rn_boost * zmsk_boost(:,:)
	379	!
	380	ELSE !* no boost: boost factor = 1
	381	zmsk_boost(:,:) = 1._wp
	382	ENDIF
	383	! !* mask outside ocean cavities area (top) or land area (bot)
	384	IF(ll_top) zmsk_boost(:,:) = zmsk_boost(:,:) * ssmask(:,:) * (1. - tmask(:,:,1) ) ! none zero in ocean cavities only
	385	IF(ll_bot) zmsk_boost(:,:) = zmsk_boost(:,:) * ssmask(:,:) ! x seafloor mask
	386	!
	387	!
	388	SELECT CASE( ndrg )
	389	!
[9526]	390	CASE( np_OFF ) !== No top/bottom friction ==! (pCdU = 0)
[8215]	391	IF(lwp) WRITE(numout,*)
[9190]	392	IF(lwp) WRITE(numout,*) ' ==>>> ',TRIM(cd_topbot),' free-slip, friction set to zero'
[8215]	393	!
	394	l_zdfdrg = .FALSE. ! no time variation of the drag: set it one for all
	395	!
[9089]	396	pCdU(:,:) = 0._wp
	397	pCd0(:,:) = 0._wp
[8215]	398	!
	399	CASE( np_lin ) !== linear friction ==! (pCdU = Cd0 * Uc0)
	400	IF(lwp) WRITE(numout,*)
[9190]	401	IF(lwp) WRITE(numout,) ' ==>>> linear ',TRIM(cd_topbot),' friction (constant coef = Cd0Uc0 = ', rn_Cd0*rn_Uc0, ')'
[8215]	402	!
	403	l_zdfdrg = .FALSE. ! no time variation of the Cd*\|U\| : set it one for all
	404	!
[9089]	405	pCd0(:,:) = rn_Cd0 * zmsk_boost(:,:) !* constant in time drag coefficient (= mask (and boost) Cd0)
	406	pCdU(:,:) = - pCd0(:,:) * rn_Uc0 ! using a constant velocity
[8215]	407	!
	408	CASE( np_non_lin ) !== non-linear friction ==! (pCd0 = Cd0 )
	409	IF(lwp) WRITE(numout,*)
[9190]	410	IF(lwp) WRITE(numout,*) ' ==>>> quadratic ',TRIM(cd_topbot),' friction (propotional to module of the velocity)'
	411	IF(lwp) WRITE(numout,*) ' with a drag coefficient Cd0 = ', rn_Cd0, ', and'
	412	IF(lwp) WRITE(numout,*) ' a background velocity module of (rn_ke0)^1/2 = ', SQRT(rn_ke0), 'm/s)'
[8215]	413	!
	414	l_zdfdrg = .TRUE. !* Cd*\|U\| updated at each time-step (it depends on ocean velocity)
	415	!
	416	pCd0(:,:) = rn_Cd0 * zmsk_boost(:,:) !* constant in time proportionality coefficient (= mask (and boost) Cd0)
[9089]	417	pCdU(:,:) = 0._wp !
[8215]	418	!
	419	CASE( np_loglayer ) !== logarithmic layer formulation of friction ==! (CdU = (vkarman log(z/z0))^2 \|U\| )
	420	IF(lwp) WRITE(numout,*)
[9190]	421	IF(lwp) WRITE(numout,*) ' ==>>> quadratic ',TRIM(cd_topbot),' drag (propotional to module of the velocity)'
[8215]	422	IF(lwp) WRITE(numout,*) ' with a logarithmic Cd0 formulation Cd0 = ( vkarman log(z/z0) )^2 ,'
	423	IF(lwp) WRITE(numout,*) ' a background velocity module of (rn_ke0)^1/2 = ', SQRT(pke0), 'm/s), '
	424	IF(lwp) WRITE(numout,*) ' a logarithmic formulation: a roughness of ', pz0, ' meters, and '
	425	IF(lwp) WRITE(numout,*) ' a proportionality factor bounded by min/max values of ', pCdmin, pCdmax
	426	!
	427	l_zdfdrg = .TRUE. !* Cd*\|U\| updated at each time-step (it depends on ocean velocity)
	428	!
	429	IF( ln_linssh ) THEN !* pCd0 = (v log(z/z0))^2 as velocity points have a fixed z position
[9089]	430	IF(lwp) WRITE(numout,*)
	431	IF(lwp) WRITE(numout,*) ' N.B. linear free surface case, Cd0 computed one for all'
[8215]	432	!
	433	l_log_not_linssh = .FALSE. !- don't update Cd at each time step
	434	!
[13295]	435	DO_2D( 1, 1, 1, 1 )
[12377]	436	zzz = 0.5_wp * e3t_0(ji,jj,k_mk(ji,jj))
	437	zcd = ( vkarmn / LOG( zzz / rn_z0 ) )**2
	438	pCd0(ji,jj) = zmsk_boost(ji,jj) * MIN( MAX( rn_Cd0 , zcd ) , rn_Cdmax ) ! rn_Cd0 < Cd0 < rn_Cdmax
	439	END_2D
[8215]	440	ELSE !* Cd updated at each time-step ==> pCd0 = mask * boost
	441	IF(lwp) WRITE(numout,*)
	442	IF(lwp) WRITE(numout,*) ' N.B. non-linear free surface case, Cd0 updated at each time-step '
	443	!
	444	l_log_not_linssh = .TRUE. ! compute the drag coef. at each time-step
	445	!
	446	pCd0(:,:) = zmsk_boost(:,:)
	447	ENDIF
[9089]	448	pCdU(:,:) = 0._wp ! initialisation to zero (will be updated at each time step)
[8215]	449	!
	450	CASE DEFAULT
	451	CALL ctl_stop( 'drg_init: bad flag value for ndrg ' )
	452	END SELECT
	453	!
	454	END SUBROUTINE drg_init
	455
	456	!!======================================================================
	457	END MODULE zdfdrg

Note: See TracBrowser for help on using the repository browser.

Download in other formats: