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 branches/2017/dev_r7881_HPC09_ZDF/NEMOGCM/NEMO/OPA_SRC/ZDF – NEMO

source: branches/2017/dev_r7881_HPC09_ZDF/NEMOGCM/NEMO/OPA_SRC/ZDF/zdfdrg.F90 @ 8093

Last change on this file since 8093 was 8093, checked in by gm, 7 years ago

#1880 (HPC-09) - step-6: prepare some forthcoming evolutions (ZDF modules mainly)
File size: 21.0 KB
Line 
1MODULE 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   !!----------------------------------------------------------------------
13
14   !!----------------------------------------------------------------------
15   !!   zdf_drg       : update bottom friction coefficient (non-linear bottom friction only)
16   !!   zdf_drg_init  : read in namdrg namelist and control the bottom friction parameters.
17   !!       drg_init  :
18   !!----------------------------------------------------------------------
19   USE oce            ! ocean dynamics and tracers variables
20   USE phycst   , ONLY: vkarmn
21   USE dom_oce        ! ocean space and time domain variables
22   USE zdf_oce        ! ocean vertical physics variables
23   !
24   USE in_out_manager ! I/O manager
25   USE iom            ! I/O module
26   USE lbclnk         ! ocean lateral boundary conditions (or mpp link)
27   USE lib_mpp        ! distributed memory computing
28   USE prtctl         ! Print control
29   USE timing         ! Timing
30   USE wrk_nemo       ! Memory Allocation
31
32   IMPLICIT NONE
33   PRIVATE
34
35   PUBLIC   zdf_drg         ! called by zdf_phy
36   PUBLIC   zdf_drg_init    ! called by zdf_phy_init
37
38   !                                 !!* Namelist namdrg: nature of drag coefficient namelist *
39   LOGICAL          ::   ln_NONE      ! free-slip       : Cd = 0
40   LOGICAL          ::   ln_lin       !     linear  drag: Cd = Cd0_lin
41   LOGICAL          ::   ln_non_lin   ! non-linear  drag: Cd = Cd0_nl |U|
42   LOGICAL          ::   ln_loglayer  ! logarithmic drag: Cd = vkarmn/log(z/z0)
43   LOGICAL , PUBLIC ::   ln_drgimp    ! implicit top/bottom friction flag
44
45   !                                 !!* Namelist namdrg_top & _bot: TOP or BOTTOM coefficient namelist *
46   REAL(wp)         ::   rn_Cd0       !: drag coefficient                                           [ - ]
47   REAL(wp)         ::   rn_Uc0       !: characteristic velocity (linear case: tau=rho*Cd0*Uc0*u)   [m/s]
48   REAL(wp)         ::   rn_Cdmax     !: drag value maximum (ln_loglayer=T)                         [ - ]
49   REAL(wp)         ::   rn_z0        !: roughness          (ln_loglayer=T)                         [ m ]
50   REAL(wp)         ::   rn_ke0       !: background kinetic energy (non-linear case)                [m2/s2]
51   LOGICAL          ::   ln_boost     !: =T regional boost of Cd0 ; =F Cd0 horizontally uniform
52   REAL(wp)         ::     rn_boost      !: local boost factor                                       [ - ]
53
54   REAL(wp), PUBLIC ::   r_Cdmin_top, r_Cdmax_top, r_z0_top, r_ke0_top   ! set from namdrg_top namelist values
55   REAL(wp), PUBLIC ::   r_Cdmin_bot, r_Cdmax_bot, r_z0_bot, r_ke0_bot   !  -    -  namdrg_bot    -       -
56
57   INTEGER ::              ndrg       ! choice of the type of drag coefficient
58   !                                  ! associated indices:
59   INTEGER, PARAMETER ::   np_NONE     = 0   ! free-slip: drag set to zero
60   INTEGER, PARAMETER ::   np_lin      = 1   !     linear drag: Cd = Cd0_lin
61   INTEGER, PARAMETER ::   np_non_lin  = 2   ! non-linear drag: Cd = Cd0_nl |U|
62   INTEGER, PARAMETER ::   np_loglayer = 3   ! non linear drag (logarithmic formulation): Cd = vkarmn/log(z/z0)
63
64   LOGICAL , PUBLIC ::   l_zdfdrg           !: flag to update at each time step the top/bottom Cd
65   LOGICAL          ::   l_log_not_linssh   !: flag to update at each time step the position ot the velocity point
66   !
67   REAL(wp), ALLOCATABLE, SAVE, DIMENSION(:,:), PUBLIC ::   rCd0_top, rCd0_bot   !: precomputed top/bottom drag coeff. at t-point (>0)
68   REAL(wp), ALLOCATABLE, SAVE, DIMENSION(:,:), PUBLIC ::   rCdU_top, rCdU_bot   !: top/bottom drag coeff. at t-point (<0)  [m/s]
69
70   !! * Substitutions
71#  include "vectopt_loop_substitute.h90"
72   !!----------------------------------------------------------------------
73   !! NEMO/OPA 4.0 , NEMO Consortium (2011)
74   !! $Id: zdfdrg.F90 7753 2017-03-03 11:46:59Z gm $
75   !! Software governed by the CeCILL licence     (NEMOGCM/NEMO_CeCILL.txt)
76   !!----------------------------------------------------------------------
77CONTAINS
78
79   SUBROUTINE zdf_drg( kt, k_mk, pCdmin, pCdmax, pz0, pke0, pCd0, pCdU )
80      !!----------------------------------------------------------------------
81      !!                   ***  ROUTINE zdf_drg  ***
82      !!
83      !! ** Purpose :   update the top/bottom drag coefficient (non-linear case only)
84      !!
85      !! ** Method  :   In non linear friction case, the drag coeficient is
86      !!              a function of the velocity:
87      !!                          Cd = cd0 * |U+Ut|   
88      !!              where U is the top or bottom velocity and
89      !!                    Ut a tidal velocity (Ut^2 = Tidal kinetic energy
90      !!                       assumed here here to be constant)
91      !!              Depending on the input variable, the top- or bottom drag is compted
92      !!
93      !! ** Action  :   p_Cd   drag coefficient at t-point
94      !!----------------------------------------------------------------------
95      INTEGER                 , INTENT(in   ) ::   kt       ! ocean time-step index
96      !                       !               !!         !==  top or bottom variables  ==!
97      INTEGER , DIMENSION(:,:), INTENT(in   ) ::   k_mk     ! wet level (1st or last)
98      REAL(wp)                , INTENT(in   ) ::   pCdmin   ! min drag value
99      REAL(wp)                , INTENT(in   ) ::   pCdmax   ! max drag value
100      REAL(wp)                , INTENT(in   ) ::   pz0      ! roughness
101      REAL(wp)                , INTENT(in   ) ::   pke0     ! background tidal KE
102      REAL(wp), DIMENSION(:,:), INTENT(in   ) ::   pCd0     ! masked precomputed part of Cd0
103      REAL(wp), DIMENSION(:,:), INTENT(  out) ::   pCdU     ! = - Cd*|U|   (t-points) [m/s]
104      !!
105      INTEGER ::   ji, jj   ! dummy loop indices
106      INTEGER ::   imk      ! local integers
107      REAL(wp)::   zzz, zut, zvt, zcd   ! local scalars
108      !!----------------------------------------------------------------------
109      !
110      IF( nn_timing == 1 )  CALL timing_start('zdf_drg')
111      !
112      !
113      IF( l_log_not_linssh ) THEN     !==  "log layer"  ==!   compute Cd and -Cd*|U|
114         DO jj = 2, jpjm1
115            DO ji = 2, jpim1
116               imk = k_mk(ji,jj)          ! ocean bottom level at t-points
117               zut = un(ji,jj,imk) + un(ji-1,jj,imk)     ! 2 x velocity at t-point
118               zvt = vn(ji,jj,imk) + vn(ji,jj-1,imk)
119               zzz = 0.5_wp * e3t_n(ji,jj,imk)           ! altitude below/above (top/bottom) the boundary
120               !
121!!JC: possible WAD implementation should modify line below if layers vanish
122               zcd = (  vkarmn / LOG( zzz / pz0 )  )**2
123               zcd = pCd0(ji,jj) * MIN(  MAX( pCdmin , zcd ) , pCdmax  )   ! here pCd0 = mask*boost
124               pCdU(ji,jj) = - zcd * SQRT(  0.25 * ( zut*zvt + zvt*zvt ) + pke0  )
125            END DO
126         END DO
127      ELSE                                            !==  standard Cd  ==!
128         DO jj = 2, jpjm1
129            DO ji = 2, jpim1
130               imk = k_mk(ji,jj)    ! ocean bottom level at t-points
131               zut = un(ji,jj,imk) + un(ji-1,jj,imk)     ! 2 x velocity at t-point
132               zvt = vn(ji,jj,imk) + vn(ji,jj-1,imk)
133               !                                                           ! here pCd0 = mask*boost * drag
134               pCdU(ji,jj) = - pCd0(ji,jj) * SQRT(  0.25 * ( zut*zvt + zvt*zvt ) + pke0  )
135            END DO
136         END DO
137      ENDIF
138      !
139!!gm to be moved at the end of zdfphy
140      CALL lbc_lnk( pCdU, 'T', 1. )    ! Lateral boundary condition
141!!gm end
142      !
143      IF(ln_ctl)   CALL prt_ctl( tab2d_1=pCdU, clinfo1=' Cd*U ')
144      !
145      IF( nn_timing == 1 )  CALL timing_stop('zdf_drg')
146      !
147   END SUBROUTINE zdf_drg
148
149
150   SUBROUTINE zdf_drg_init
151      !!----------------------------------------------------------------------
152      !!                  ***  ROUTINE zdf_brg_init  ***
153      !!
154      !! ** Purpose :   Initialization of the bottom friction
155      !!
156      !! ** Method  :   Read the namdrg namelist and check their consistency
157      !!                called at the first timestep (nit000)
158      !!----------------------------------------------------------------------
159      INTEGER   ::   ji, jj      ! dummy loop indexes
160      INTEGER   ::   ios, ioptio   ! local integers
161      !!
162      NAMELIST/namdrg/ ln_NONE, ln_lin, ln_non_lin, ln_loglayer, ln_drgimp
163      !!----------------------------------------------------------------------
164      !
165      !                     !==  drag nature  ==!
166      !
167      REWIND( numnam_ref )                   ! Namelist namdrg in reference namelist
168      READ  ( numnam_ref, namdrg, IOSTAT = ios, ERR = 901)
169901   IF( ios /= 0 )   CALL ctl_nam( ios , 'namdrg in reference namelist', lwp )
170      REWIND( numnam_cfg )                   ! Namelist namdrg in configuration namelist
171      READ  ( numnam_cfg, namdrg, IOSTAT = ios, ERR = 902 )
172902   IF( ios /= 0 )   CALL ctl_nam( ios , 'namdrg in configuration namelist', lwp )
173      IF(lwm) WRITE ( numond, namdrg )
174      !
175      IF(lwp) THEN
176         WRITE(numout,*)
177         WRITE(numout,*) 'zdf_drg_init : top and/or bottom drag setting'
178         WRITE(numout,*) '~~~~~~~~~~~~'
179         WRITE(numout,*) '   Namelist namdrg : top/bottom friction choices'
180         WRITE(numout,*) '      free-slip       : Cd = 0                  ln_NONE     = ', ln_NONE
181         WRITE(numout,*) '      linear  drag    : Cd = Cd0                ln_lin      = ', ln_lin
182         WRITE(numout,*) '      non-linear  drag: Cd = Cd0_nl |U|         ln_non_lin  = ', ln_non_lin
183         WRITE(numout,*) '      logarithmic drag: Cd = vkarmn/log(z/z0)   ln_loglayer = ', ln_loglayer
184         WRITE(numout,*) '      implicit friction                         ln_drgimp   = ', ln_drgimp
185      ENDIF
186      !
187      ioptio = 0                       ! set ndrg and control check
188      IF( ln_NONE     ) THEN   ;   ndrg = np_NONE       ;   ioptio = ioptio + 1   ;   ENDIF
189      IF( ln_lin      ) THEN   ;   ndrg = np_lin        ;   ioptio = ioptio + 1   ;   ENDIF
190      IF( ln_non_lin  ) THEN   ;   ndrg = np_non_lin    ;   ioptio = ioptio + 1   ;   ENDIF
191      IF( ln_loglayer ) THEN   ;   ndrg = np_loglayer   ;   ioptio = ioptio + 1   ;   ENDIF
192      !
193      IF( ioptio /= 1 )   CALL ctl_stop( 'zdf_drg_init: Choose ONE type of drag coef in namdrg' )
194      !
195      IF( ln_drgimp .AND. ln_zdfexp )   CALL ctl_stop( 'zdf_drg_init: ln_drgimp=T requires ln_zdfexp' )
196
197      !
198      !                     !==  BOTTOM drag setting  ==!   (applied at seafloor)
199      !
200      ALLOCATE( rCd0_bot(jpi,jpj), rCdU_bot(jpi,jpj) )
201      CALL drg_init( 'BOTTOM'   , mbkt       ,                                         &   ! <== in
202         &           r_Cdmin_bot, r_Cdmax_bot, r_z0_bot, r_ke0_bot, rCd0_bot, rCdU_bot )   ! ==> out
203
204      !
205      !                     !==  TOP drag setting  ==!   (applied at the top of ocean cavities)
206      !
207      IF ( ln_isfcav ) THEN             ! Ocean cavities: top friction setting
208         ALLOCATE( rCd0_top(jpi,jpj), rCdU_top(jpi,jpj) )
209         CALL drg_init( 'TOP   '   , mikt       ,                                         &   ! <== in
210            &           r_Cdmin_top, r_Cdmax_top, r_z0_top, r_ke0_top, rCd0_bot, rCdU_bot )   ! ==> out
211      ENDIF
212      !
213   END SUBROUTINE zdf_drg_init
214
215
216   SUBROUTINE drg_init( cd_topbot, k_mk,  &
217      &                 pCdmin, pCdmax, pz0, pke0, pCd0, pCdU ) 
218      !!----------------------------------------------------------------------
219      !!                  ***  ROUTINE drg_init  ***
220      !!
221      !! ** Purpose :   Initialization of the top/bottom friction CdO and Cd
222      !!              from namelist parameters
223      !!----------------------------------------------------------------------
224      CHARACTER(len=6)        , INTENT(in   ) ::   cd_topbot       ! top/ bot indicator
225      INTEGER , DIMENSION(:,:), INTENT(in   ) ::   k_mk            ! 1st/last  wet level
226      REAL(wp)                , INTENT(  out) ::   pCdmin, pCdmax  ! min and max drag coef. [-]
227      REAL(wp)                , INTENT(  out) ::   pz0             ! roughness              [m]
228      REAL(wp)                , INTENT(  out) ::   pke0            ! background KE          [m2/s2]
229      REAL(wp), DIMENSION(:,:), INTENT(  out) ::   pCd0            ! masked precomputed part of the non-linear drag coefficient
230      REAL(wp), DIMENSION(:,:), INTENT(  out) ::   pCdU            ! linear drag*|U| at t-points  [m/s]
231      !!
232      CHARACTER(len=40) ::   cl_namdrg, cl_file, cl_varname, cl_namref, cl_namcfg  ! local names
233      INTEGER ::   ji, jj              ! dummy loop indexes
234      LOGICAL ::   ll_top, ll_bot      ! local logical
235      INTEGER ::   ios, inum, imk      ! local integers
236      REAL(wp)::   zmsk, zzz, zcd      ! local scalars
237      REAL(wp), DIMENSION(jpi,jpj) ::   zmsk_boost   ! 2D workspace
238      !!
239      NAMELIST/namdrg_top/ rn_Cd0, rn_Uc0, rn_Cdmax, rn_ke0, rn_z0, ln_boost, rn_boost
240      NAMELIST/namdrg_bot/ rn_Cd0, rn_Uc0, rn_Cdmax, rn_ke0, rn_z0, ln_boost, rn_boost
241      !!----------------------------------------------------------------------
242      !
243      !                          !==  set TOP / BOTTOM specificities  ==!
244      ll_top = .FALSE.
245      ll_bot = .FALSE.
246      !
247      SELECT CASE (cd_topbot)
248      CASE( 'TOP   ' )
249         ll_top = .TRUE.
250         cl_namdrg  = 'namdrg_top'
251         cl_namref  = 'namdrg_top in reference     namelist'
252         cl_namcfg  = 'namdrg_top in configuration namelist'
253         cl_file    = 'tfr_coef.nc'
254         cl_varname = 'tfr_coef'
255      CASE( 'BOTTOM' )
256         ll_bot = .TRUE.
257         cl_namdrg  = 'namdrg_bot'
258         cl_namref  = 'namdrg_bot  in reference     namelist'
259         cl_namcfg  = 'namdrg_bot  in configuration namelist'
260         cl_file    = 'bfr_coef.nc'
261         cl_varname = 'tfr_coef'
262      CASE DEFAULT
263         CALL ctl_stop( 'drg_init: bad value for cd_topbot ' )
264      END SELECT
265      !
266      !                          !==  read namlist  ==!
267      !
268      REWIND( numnam_ref )                   ! Namelist cl_namdrg in reference namelist
269      IF(ll_top)   READ  ( numnam_ref, namdrg_top, IOSTAT = ios, ERR = 901)
270      IF(ll_bot)   READ  ( numnam_ref, namdrg_bot, IOSTAT = ios, ERR = 901)
271901   IF( ios /= 0 )   CALL ctl_nam( ios , TRIM(cl_namref), lwp )
272      REWIND( numnam_cfg )                   ! Namelist cd_namdrg in configuration namelist
273      IF(ll_top)   READ  ( numnam_cfg, namdrg_top, IOSTAT = ios, ERR = 902 )
274      IF(ll_bot)   READ  ( numnam_cfg, namdrg_bot, IOSTAT = ios, ERR = 902 )
275902   IF( ios /= 0 )   CALL ctl_nam( ios , TRIM(cl_namcfg), lwp )
276      IF(lwm .AND. ll_top)   WRITE ( numond, namdrg_top )
277      IF(lwm .AND. ll_bot)   WRITE ( numond, namdrg_bot )
278      !
279      IF(lwp) THEN
280         WRITE(numout,*)
281         WRITE(numout,*) '   Namelist ',TRIM(cl_namdrg),' : set ',TRIM(cd_topbot),' friction parameters'
282         WRITE(numout,*) '      drag coefficient                        rn_Cd0   = ', rn_Cd0
283         WRITE(numout,*) '      characteristic velocity (linear case)   rn_Uc0   = ', rn_Uc0, ' m/s'
284         WRITE(numout,*) '      non-linear drag maximum                 rn_Cdmax = ', rn_Cdmax
285         WRITE(numout,*) '      background kinetic energy  (n-l case)   rn_ke0   = ', rn_ke0
286         WRITE(numout,*) '      bottom roughness           (n-l case)   rn_z0    = ', rn_z0
287         WRITE(numout,*) '      set a regional boost of Cd0             ln_boost = ', ln_boost
288         WRITE(numout,*) '         associated boost factor              rn_boost = ', rn_boost
289      ENDIF
290      !
291      !                          !==  return some namelist parametres  ==!   (used in non_lin and loglayer cases)
292      pCdmin = rn_Cd0
293      pCdmax = rn_Cdmax
294      pz0    = rn_z0
295      pke0   = rn_ke0
296      !
297      !                          !==  mask * boost factor  ==!
298      !
299      IF( ln_boost ) THEN           !* regional boost:   boost factor = 1 + regional boost
300         IF(lwp) WRITE(numout,*)
301         IF(lwp) WRITE(numout,*) '   ==>>   use a regional boost read in ', TRIM(cl_file), ' file'
302         IF(lwp) WRITE(numout,*) '          using enhancement factor of ', rn_boost
303         ! cl_varname is a coefficient in [0,1] giving where to apply the regional boost
304         CALL iom_open ( TRIM(cl_file), inum )
305         CALL iom_get  ( inum, jpdom_data, TRIM(cl_varname), zmsk_boost, 1 )
306         CALL iom_close( inum)
307         zmsk_boost(:,:) = 1._wp + rn_boost * zmsk_boost(:,:)
308         !
309      ELSE                          !* no boost:   boost factor = 1
310         zmsk_boost(:,:) = 1._wp
311      ENDIF
312      !                             !* mask outside ocean cavities area (top) or land area (bot)
313      IF(ll_top)   zmsk_boost(:,:) = zmsk_boost(:,:) * ssmask(:,:) * (1. - tmask(:,:,1) )  ! none zero in ocean cavities only
314      IF(ll_bot)   zmsk_boost(:,:) = zmsk_boost(:,:) * ssmask(:,:)                         ! x seafloor mask
315      !
316      !
317      SELECT CASE( ndrg )
318      !
319      CASE( np_NONE )            !==  No top/bottom friction  ==!   (pCdU = 0)
320         IF(lwp) WRITE(numout,*)
321         IF(lwp) WRITE(numout,*) '   ==>>   ',TRIM(cd_topbot),' free-slip, friction set to zero'
322         !
323         l_zdfdrg = .FALSE.         ! no time variation of the drag: set it one for all
324         !
325         pCdU(:,:) = 0._wp          ! pCd0 never used
326         !
327      CASE( np_lin )             !==  linear friction  ==!   (pCdU = Cd0 * Uc0)
328         IF(lwp) WRITE(numout,*)
329         IF(lwp) WRITE(numout,*) '   ==>>   linear ',TRIM(cd_topbot),' friction (constant coef = Cd0*Uc0 = ', rn_Cd0*rn_Uc0, ')'
330         !
331         l_zdfdrg = .FALSE.         ! no time variation of the Cd*|U| : set it one for all
332         !                     
333         pCdU(:,:) = - rn_Cd0 * rn_Uc0 * zmsk_boost(:,:)   ! pCd0 never used: remain undefined
334         !
335      CASE( np_non_lin )         !== non-linear friction  ==!   (pCd0 = Cd0 )
336         IF(lwp) WRITE(numout,*)
337         IF(lwp) WRITE(numout,*) '   ==>>   quadratic ',TRIM(cd_topbot),' friction (propotional to module of the velocity)'
338         IF(lwp) WRITE(numout,*) '   with   Cd0 = ', rn_Cd0, ', and',   &
339            &                             ' a background velocity module of (rn_ke0)^1/2 = ', SQRT(rn_ke0), 'm/s)'
340         !
341         l_zdfdrg = .TRUE.          !* Cd*|U| updated at each time-step (it depends on ocean velocity)
342         !
343         pCd0(:,:) = rn_Cd0 * zmsk_boost(:,:)  !* constant in time proportionality coefficient (= mask (and boost) Cd0)
344         !
345      CASE( np_loglayer )       !== logarithmic layer formulation of friction  ==!   (CdU = (vkarman log(z/z0))^2 |U| )
346         IF(lwp) WRITE(numout,*)
347         IF(lwp) WRITE(numout,*) '   ==>>   quadratic ',TRIM(cd_topbot),' drag (propotional to module of the velocity)'
348         IF(lwp) WRITE(numout,*) '   with   a logarithmic Cd0 formulation Cd0 = ( vkarman log(z/z0) )^2 ,'
349         IF(lwp) WRITE(numout,*) '          a background velocity module of (rn_ke0)^1/2 = ', SQRT(pke0), 'm/s), '
350         IF(lwp) WRITE(numout,*) '          a logarithmic formulation: a roughness of ', pz0, ' meters,   and '
351         IF(lwp) WRITE(numout,*) '          a proportionality factor bounded by min/max values of ', pCdmin, pCdmax
352         !
353         l_zdfdrg = .TRUE.          !* Cd*|U| updated at each time-step (it depends on ocean velocity)
354         !
355         IF( ln_linssh ) THEN       !* pCd0 = (v log(z/z0))^2   as velocity points have a fixed z position
356         IF(lwp) WRITE(numout,*)
357         IF(lwp) WRITE(numout,*) '   N.B.   linear free surface case, Cd0 computed one for all'
358            !
359            l_log_not_linssh = .FALSE.    !- don't update Cd at each time step
360            !
361            DO jj = 1, jpj                   ! pCd0 = mask (and boosted) logarithmic drag coef.
362               DO ji = 1, jpi
363                  zzz =  0.5_wp * e3t_0(ji,jj,k_mk(ji,jj))
364                  zcd = (  vkarmn / LOG( zzz / rn_z0 )  )**2
365                  pCd0(ji,jj) = zmsk_boost(ji,jj) * MIN(  MAX( rn_Cd0 , zcd ) , rn_Cdmax  )  ! rn_Cd0 < Cd0 < rn_Cdmax
366               END DO
367            END DO
368         ELSE                       !* Cd updated at each time-step ==> pCd0 = mask * boost
369            IF(lwp) WRITE(numout,*)
370            IF(lwp) WRITE(numout,*) '   N.B.   non-linear free surface case, Cd0 updated at each time-step '
371            !
372            l_log_not_linssh = .TRUE.     ! compute the drag coef. at each time-step
373            !
374            pCd0(:,:) = zmsk_boost(:,:)
375         ENDIF
376         !
377      CASE DEFAULT
378         CALL ctl_stop( 'drg_init: bad flag value for ndrg ' )
379      END SELECT
380      !
381   END SUBROUTINE drg_init
382
383   !!======================================================================
384END MODULE zdfdrg
Note: See TracBrowser for help on using the repository browser.