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.
dynnxt.F90 in NEMO/branches/2018/dev_r10057_ENHANCE03_ZTILDE/src/OCE/DYN – NEMO

source: NEMO/branches/2018/dev_r10057_ENHANCE03_ZTILDE/src/OCE/DYN/dynnxt.F90 @ 10116

Last change on this file since 10116 was 10116, checked in by jchanut, 6 years ago

ztilde update (3): #2126
Rewrite thickness advection, add regriding, biharmonic interface diffusion
  • Property svn:keywords set to Id
File size: 19.9 KB
Line 
1MODULE dynnxt
2   !!=========================================================================
3   !!                       ***  MODULE  dynnxt  ***
4   !! Ocean dynamics: time stepping
5   !!=========================================================================
6   !! History :  OPA  !  1987-02  (P. Andrich, D. L Hostis)  Original code
7   !!                 !  1990-10  (C. Levy, G. Madec)
8   !!            7.0  !  1993-03  (M. Guyon)  symetrical conditions
9   !!            8.0  !  1997-02  (G. Madec & M. Imbard)  opa, release 8.0
10   !!            8.2  !  1997-04  (A. Weaver)  Euler forward step
11   !!             -   !  1997-06  (G. Madec)  lateral boudary cond., lbc routine
12   !!    NEMO    1.0  !  2002-08  (G. Madec)  F90: Free form and module
13   !!             -   !  2002-10  (C. Talandier, A-M. Treguier) Open boundary cond.
14   !!            2.0  !  2005-11  (V. Garnier) Surface pressure gradient organization
15   !!            2.3  !  2007-07  (D. Storkey) Calls to BDY routines.
16   !!            3.2  !  2009-06  (G. Madec, R.Benshila)  re-introduce the vvl option
17   !!            3.3  !  2010-09  (D. Storkey, E.O'Dea) Bug fix for BDY module
18   !!            3.3  !  2011-03  (P. Oddo) Bug fix for time-splitting+(BDY-OBC) and not VVL
19   !!            3.5  !  2013-07  (J. Chanut) Compliant with time splitting changes
20   !!            3.6  !  2014-04  (G. Madec) add the diagnostic of the time filter trends
21   !!            3.7  !  2015-11  (J. Chanut) Free surface simplification
22   !!-------------------------------------------------------------------------
23 
24   !!-------------------------------------------------------------------------
25   !!   dyn_nxt       : obtain the next (after) horizontal velocity
26   !!-------------------------------------------------------------------------
27   USE oce            ! ocean dynamics and tracers
28   USE dom_oce        ! ocean space and time domain
29   USE sbc_oce        ! Surface boundary condition: ocean fields
30   USE sbcrnf         ! river runoffs
31   USE sbcisf         ! ice shelf
32   USE phycst         ! physical constants
33   USE dynadv         ! dynamics: vector invariant versus flux form
34   USE dynspg_ts      ! surface pressure gradient: split-explicit scheme
35   USE domvvl         ! variable volume
36   USE bdy_oce   , ONLY: ln_bdy
37   USE bdydta         ! ocean open boundary conditions
38   USE bdydyn         ! ocean open boundary conditions
39   USE bdyvol         ! ocean open boundary condition (bdy_vol routines)
40   USE trd_oce        ! trends: ocean variables
41   USE trddyn         ! trend manager: dynamics
42   USE trdken         ! trend manager: kinetic energy
43   !
44   USE in_out_manager ! I/O manager
45   USE iom            ! I/O manager library
46   USE lbclnk         ! lateral boundary condition (or mpp link)
47   USE lib_mpp        ! MPP library
48   USE prtctl         ! Print control
49   USE timing         ! Timing
50#if defined key_agrif
51   USE agrif_oce_interp
52#endif
53
54   IMPLICIT NONE
55   PRIVATE
56
57   PUBLIC    dyn_nxt   ! routine called by step.F90
58
59   !!----------------------------------------------------------------------
60   !! NEMO/OCE 4.0 , NEMO Consortium (2018)
61   !! $Id$
62   !! Software governed by the CeCILL licence     (./LICENSE)
63   !!----------------------------------------------------------------------
64CONTAINS
65
66   SUBROUTINE dyn_nxt ( kt )
67      !!----------------------------------------------------------------------
68      !!                  ***  ROUTINE dyn_nxt  ***
69      !!                   
70      !! ** Purpose :   Finalize after horizontal velocity. Apply the boundary
71      !!             condition on the after velocity, achieve the time stepping
72      !!             by applying the Asselin filter on now fields and swapping
73      !!             the fields.
74      !!
75      !! ** Method  : * Ensure after velocities transport matches time splitting
76      !!             estimate (ln_dynspg_ts=T)
77      !!
78      !!              * Apply lateral boundary conditions on after velocity
79      !!             at the local domain boundaries through lbc_lnk call,
80      !!             at the one-way open boundaries (ln_bdy=T),
81      !!             at the AGRIF zoom   boundaries (lk_agrif=T)
82      !!
83      !!              * Apply the time filter applied and swap of the dynamics
84      !!             arrays to start the next time step:
85      !!                (ub,vb) = (un,vn) + atfp [ (ub,vb) + (ua,va) - 2 (un,vn) ]
86      !!                (un,vn) = (ua,va).
87      !!             Note that with flux form advection and non linear free surface,
88      !!             the time filter is applied on thickness weighted velocity.
89      !!             As a result, dyn_nxt MUST be called after tra_nxt.
90      !!
91      !! ** Action :   ub,vb   filtered before horizontal velocity of next time-step
92      !!               un,vn   now horizontal velocity of next time-step
93      !!----------------------------------------------------------------------
94      INTEGER, INTENT( in ) ::   kt      ! ocean time-step index
95      !
96      INTEGER  ::   ji, jj, jk   ! dummy loop indices
97      INTEGER  ::   ikt, jkbot   ! local integers
98      REAL(wp) ::   zue3a, zue3n, zue3b, zuf, zcoef    ! local scalars
99      REAL(wp) ::   zve3a, zve3n, zve3b, zvf, z1_2dt   !   -      -
100      REAL(wp) ::   zhcri, zmsku, zwgtu, zmskv, zwgtv  !   -      -
101      REAL(wp), ALLOCATABLE, DIMENSION(:,:)   ::   zue, zve
102      REAL(wp), ALLOCATABLE, DIMENSION(:,:,:) ::   ze3u_f, ze3v_f, zua, zva 
103      !!----------------------------------------------------------------------
104      !
105      IF( ln_timing    )   CALL timing_start('dyn_nxt')
106      IF( ln_dynspg_ts )   ALLOCATE( zue(jpi,jpj)     , zve(jpi,jpj)     )
107      IF( l_trddyn     )   ALLOCATE( zua(jpi,jpj,jpk) , zva(jpi,jpj,jpk) )
108      !
109      IF( kt == nit000 ) THEN
110         IF(lwp) WRITE(numout,*)
111         IF(lwp) WRITE(numout,*) 'dyn_nxt : time stepping'
112         IF(lwp) WRITE(numout,*) '~~~~~~~'
113      ENDIF
114
115      IF ( ln_dynspg_ts ) THEN
116         ! Ensure below that barotropic velocities match time splitting estimate
117         ! Compute actual transport and replace it with ts estimate at "after" time step
118         zue(:,:) = e3u_a(:,:,1) * ua(:,:,1) * umask(:,:,1)
119         zve(:,:) = e3v_a(:,:,1) * va(:,:,1) * vmask(:,:,1)
120         DO jk = 2, jpkm1
121            zue(:,:) = zue(:,:) + e3u_a(:,:,jk) * ua(:,:,jk) * umask(:,:,jk)
122            zve(:,:) = zve(:,:) + e3v_a(:,:,jk) * va(:,:,jk) * vmask(:,:,jk)
123         END DO
124         DO jk = 1, jpkm1
125            ua(:,:,jk) = ( ua(:,:,jk) - zue(:,:) * r1_hu_a(:,:) + ua_b(:,:) ) * umask(:,:,jk)
126            va(:,:,jk) = ( va(:,:,jk) - zve(:,:) * r1_hv_a(:,:) + va_b(:,:) ) * vmask(:,:,jk)
127         END DO
128         !
129         IF( .NOT.ln_bt_fw ) THEN
130            ! Remove advective velocity from "now velocities"
131            ! prior to asselin filtering     
132            ! In the forward case, this is done below after asselin filtering   
133            ! so that asselin contribution is removed at the same time
134            DO jk = 1, jpkm1
135               un(:,:,jk) = ( un(:,:,jk) - un_adv(:,:)*r1_hu_n(:,:) + un_b(:,:) )*umask(:,:,jk)
136               vn(:,:,jk) = ( vn(:,:,jk) - vn_adv(:,:)*r1_hv_n(:,:) + vn_b(:,:) )*vmask(:,:,jk)
137            END DO 
138         ENDIF
139      ENDIF
140
141      IF( ln_vvl_ztilde .OR. ln_vvl_layer) THEN 
142!         ! Duplicate baroclinic velocities from above in massless layers
143!         ! Correction to handle correct barotropic velocities right after
144         zhcri = 0.1_wp
145         DO ji = 2, jpim1
146            DO jj= 2, jpjm1
147               jkbot=jpkm1
148               DO jk=jpkm1,2,-1
149                  IF (e3u_a(ji,jj,jk)>zhcri) jkbot = jk+1
150               END DO
151               DO jk=jkbot,jpkm1
152                  zwgtu = MIN(zhcri, e3u_a(ji,jj,jk))
153                  zmsku = 0.5_wp * ( 1._wp + SIGN(1._wp, e3u_a(ji,jj,jk) - 0.01_wp) )
154                  ua(ji,jj,jk) = zmsku * (zwgtu * ua(ji,jj,jk) + (zhcri - zwgtu) * ua(ji,jj,jk-1)*zwgtu/(zwgtu+0.01_wp)) / zhcri
155               END DO
156               jkbot=jpkm1
157               DO jk=jpkm1,2,-1
158                  IF (e3v_a(ji,jj,jk)>zhcri) jkbot = jk+1
159               END DO
160               DO jk=jkbot,jpkm1
161                  zwgtv = MIN(zhcri, e3v_a(ji,jj,jk))
162                  zmskv = 0.5_wp * ( 1._wp + SIGN(1._wp, e3v_a(ji,jj,jk) - 0.01_wp) )
163                  va(ji,jj,jk) = zmskv * (zwgtv * va(ji,jj,jk) + (zhcri - zwgtv) * va(ji,jj,jk-1)*zwgtv/(zwgtv+0.01_wp)) / zhcri
164               END DO
165            END DO
166         END DO
167      ENDIF
168
169      ! Update after velocity on domain lateral boundaries
170      ! --------------------------------------------------     
171# if defined key_agrif
172      CALL Agrif_dyn( kt )             !* AGRIF zoom boundaries
173# endif
174      !
175      CALL lbc_lnk_multi( ua, 'U', -1., va, 'V', -1. )     !* local domain boundaries
176      !
177      !                                !* BDY open boundaries
178      IF( ln_bdy .AND. ln_dynspg_exp )   CALL bdy_dyn( kt )
179      IF( ln_bdy .AND. ln_dynspg_ts  )   CALL bdy_dyn( kt, dyn3d_only=.true. )
180
181!!$   Do we need a call to bdy_vol here??
182      !
183      IF( l_trddyn ) THEN             ! prepare the atf trend computation + some diagnostics
184         z1_2dt = 1._wp / (2. * rdt)        ! Euler or leap-frog time step
185         IF( neuler == 0 .AND. kt == nit000 )   z1_2dt = 1._wp / rdt
186         !
187         !                                  ! Kinetic energy and Conversion
188         IF( ln_KE_trd  )   CALL trd_dyn( ua, va, jpdyn_ken, kt )
189         !
190         IF( ln_dyn_trd ) THEN              ! 3D output: total momentum trends
191            zua(:,:,:) = ( ua(:,:,:) - ub(:,:,:) ) * z1_2dt
192            zva(:,:,:) = ( va(:,:,:) - vb(:,:,:) ) * z1_2dt
193            CALL iom_put( "utrd_tot", zua )        ! total momentum trends, except the asselin time filter
194            CALL iom_put( "vtrd_tot", zva )
195         ENDIF
196         !
197         zua(:,:,:) = un(:,:,:)             ! save the now velocity before the asselin filter
198         zva(:,:,:) = vn(:,:,:)             ! (caution: there will be a shift by 1 timestep in the
199         !                                  !  computation of the asselin filter trends)
200      ENDIF
201
202      ! Time filter and swap of dynamics arrays
203      ! ------------------------------------------
204      IF( neuler == 0 .AND. kt == nit000 ) THEN        !* Euler at first time-step: only swap
205         DO jk = 1, jpkm1
206            un(:,:,jk) = ua(:,:,jk)                         ! un <-- ua
207            vn(:,:,jk) = va(:,:,jk)
208         END DO
209         IF( .NOT.ln_linssh ) THEN                          ! e3._b <-- e3._n
210!!gm BUG ????    I don't understand why it is not : e3._n <-- e3._a 
211            DO jk = 1, jpkm1
212!               e3t_b(:,:,jk) = e3t_n(:,:,jk)
213!               e3u_b(:,:,jk) = e3u_n(:,:,jk)
214!               e3v_b(:,:,jk) = e3v_n(:,:,jk)
215               !
216               e3t_n(:,:,jk) = e3t_a(:,:,jk)
217               e3u_n(:,:,jk) = e3u_a(:,:,jk)
218               e3v_n(:,:,jk) = e3v_a(:,:,jk)
219            END DO
220!!gm BUG end
221         ENDIF
222                                                            !
223         
224      ELSE                                             !* Leap-Frog : Asselin filter and swap
225         !                                ! =============!
226         IF( ln_linssh ) THEN             ! Fixed volume !
227            !                             ! =============!
228            DO jk = 1, jpkm1                             
229               DO jj = 1, jpj
230                  DO ji = 1, jpi   
231                     zuf = un(ji,jj,jk) + atfp * ( ub(ji,jj,jk) - 2._wp * un(ji,jj,jk) + ua(ji,jj,jk) )
232                     zvf = vn(ji,jj,jk) + atfp * ( vb(ji,jj,jk) - 2._wp * vn(ji,jj,jk) + va(ji,jj,jk) )
233                     !
234                     ub(ji,jj,jk) = zuf                      ! ub <-- filtered velocity
235                     vb(ji,jj,jk) = zvf
236                     un(ji,jj,jk) = ua(ji,jj,jk)             ! un <-- ua
237                     vn(ji,jj,jk) = va(ji,jj,jk)
238                  END DO
239               END DO
240            END DO
241            !                             ! ================!
242         ELSE                             ! Variable volume !
243            !                             ! ================!
244            ! Before scale factor at t-points
245            ! (used as a now filtered scale factor until the swap)
246            ! ----------------------------------------------------
247            DO jk = 1, jpkm1
248               e3t_b(:,:,jk) = e3t_n(:,:,jk) + atfp * ( e3t_b(:,:,jk) - 2._wp * e3t_n(:,:,jk) + e3t_a(:,:,jk) )
249            END DO
250            ! Add volume filter correction: compatibility with tracer advection scheme
251            ! => time filter + conservation correction (only at the first level)
252            zcoef = atfp * rdt * r1_rau0
253
254            e3t_b(:,:,1) = e3t_b(:,:,1) - zcoef * ( emp_b(:,:) - emp(:,:) ) * tmask(:,:,1)
255
256            IF ( ln_rnf ) THEN
257               IF( ln_rnf_depth ) THEN
258                  DO jk = 1, jpkm1 ! Deal with Rivers separetely, as can be through depth too
259                     DO jj = 1, jpj
260                        DO ji = 1, jpi
261                           IF( jk <=  nk_rnf(ji,jj)  ) THEN
262                               e3t_b(ji,jj,jk) =   e3t_b(ji,jj,jk) - zcoef *  ( - rnf_b(ji,jj) + rnf(ji,jj) ) &
263                                      &          * ( e3t_n(ji,jj,jk) / h_rnf(ji,jj) ) * tmask(ji,jj,jk)
264                           ENDIF
265                        ENDDO
266                     ENDDO
267                  ENDDO
268               ELSE
269                  e3t_b(:,:,1) = e3t_b(:,:,1) - zcoef *  ( -rnf_b(:,:) + rnf(:,:))*tmask(:,:,1)
270               ENDIF
271            END IF
272
273            IF ( ln_isf ) THEN   ! if ice shelf melting
274               DO jk = 1, jpkm1 ! Deal with isf separetely, as can be through depth too
275                  DO jj = 1, jpj
276                     DO ji = 1, jpi
277                        IF( misfkt(ji,jj) <= jk .AND. jk <= misfkb(ji,jj) ) THEN
278                           e3t_b(ji,jj,jk) =   e3t_b(ji,jj,jk) - zcoef *  ( fwfisf_b(ji,jj) - fwfisf(ji,jj) ) &
279                                &          * ( e3t_n(ji,jj,jk) * r1_hisf_tbl(ji,jj) ) * tmask(ji,jj,jk)
280                        ENDIF
281                     END DO
282                  END DO
283               END DO
284            END IF
285            !
286            IF( ln_dynadv_vec ) THEN      ! Asselin filter applied on velocity
287               ! Before filtered scale factor at (u/v)-points
288               CALL dom_vvl_interpol( e3t_b(:,:,:), e3u_b(:,:,:), 'U' )
289               CALL dom_vvl_interpol( e3t_b(:,:,:), e3v_b(:,:,:), 'V' )
290               DO jk = 1, jpkm1
291                  DO jj = 1, jpj
292                     DO ji = 1, jpi
293                        zuf = un(ji,jj,jk) + atfp * ( ub(ji,jj,jk) - 2._wp * un(ji,jj,jk) + ua(ji,jj,jk) )
294                        zvf = vn(ji,jj,jk) + atfp * ( vb(ji,jj,jk) - 2._wp * vn(ji,jj,jk) + va(ji,jj,jk) )
295                        !
296                        ub(ji,jj,jk) = zuf                      ! ub <-- filtered velocity
297                        vb(ji,jj,jk) = zvf
298                        un(ji,jj,jk) = ua(ji,jj,jk)             ! un <-- ua
299                        vn(ji,jj,jk) = va(ji,jj,jk)
300                     END DO
301                  END DO
302               END DO
303               !
304            ELSE                          ! Asselin filter applied on thickness weighted velocity
305               !
306               ALLOCATE( ze3u_f(jpi,jpj,jpk) , ze3v_f(jpi,jpj,jpk) )
307               ! Before filtered scale factor at (u/v)-points stored in ze3u_f, ze3v_f
308               CALL dom_vvl_interpol( e3t_b(:,:,:), ze3u_f, 'U' )
309               CALL dom_vvl_interpol( e3t_b(:,:,:), ze3v_f, 'V' )
310               DO jk = 1, jpkm1
311                  DO jj = 1, jpj
312                     DO ji = 1, jpi                 
313                        zue3a = e3u_a(ji,jj,jk) * ua(ji,jj,jk)
314                        zve3a = e3v_a(ji,jj,jk) * va(ji,jj,jk)
315                        zue3n = e3u_n(ji,jj,jk) * un(ji,jj,jk)
316                        zve3n = e3v_n(ji,jj,jk) * vn(ji,jj,jk)
317                        zue3b = e3u_b(ji,jj,jk) * ub(ji,jj,jk)
318                        zve3b = e3v_b(ji,jj,jk) * vb(ji,jj,jk)
319                        !
320                        zuf = ( zue3n + atfp * ( zue3b - 2._wp * zue3n  + zue3a ) ) / ze3u_f(ji,jj,jk)
321                        zvf = ( zve3n + atfp * ( zve3b - 2._wp * zve3n  + zve3a ) ) / ze3v_f(ji,jj,jk)
322                        zmsku = 0.5_wp * ( 1._wp + SIGN(1._wp, ze3u_f(ji,jj,jk) - 0.01_wp) )
323                        zmskv = 0.5_wp * ( 1._wp + SIGN(1._wp, ze3v_f(ji,jj,jk) - 0.01_wp) )
324                        !
325                        ub(ji,jj,jk) = zmsku * zuf             ! ub <-- filtered velocity
326                        vb(ji,jj,jk) = zmskv * zvf
327                        un(ji,jj,jk) = ua(ji,jj,jk)            ! un <-- ua
328                        vn(ji,jj,jk) = va(ji,jj,jk)
329                     END DO
330                  END DO
331               END DO
332               e3u_b(:,:,1:jpkm1) = ze3u_f(:,:,1:jpkm1)        ! e3u_b <-- filtered scale factor
333               e3v_b(:,:,1:jpkm1) = ze3v_f(:,:,1:jpkm1)
334               !
335               DEALLOCATE( ze3u_f , ze3v_f )
336            ENDIF
337            !
338         ENDIF
339         !
340         IF( ln_dynspg_ts .AND. ln_bt_fw ) THEN
341            ! Revert "before" velocities to time split estimate
342            ! Doing it here also means that asselin filter contribution is removed 
343            zue(:,:) = e3u_b(:,:,1) * ub(:,:,1) * umask(:,:,1)
344            zve(:,:) = e3v_b(:,:,1) * vb(:,:,1) * vmask(:,:,1)   
345            DO jk = 2, jpkm1
346               zue(:,:) = zue(:,:) + e3u_b(:,:,jk) * ub(:,:,jk) * umask(:,:,jk)
347               zve(:,:) = zve(:,:) + e3v_b(:,:,jk) * vb(:,:,jk) * vmask(:,:,jk)   
348            END DO
349            DO jk = 1, jpkm1
350               ub(:,:,jk) = ub(:,:,jk) - (zue(:,:) * r1_hu_n(:,:) - un_b(:,:)) * umask(:,:,jk)
351               vb(:,:,jk) = vb(:,:,jk) - (zve(:,:) * r1_hv_n(:,:) - vn_b(:,:)) * vmask(:,:,jk)
352            END DO
353         ENDIF
354         !
355      ENDIF ! neuler =/0
356      !
357      ! Set "now" and "before" barotropic velocities for next time step:
358      ! JC: Would be more clever to swap variables than to make a full vertical
359      ! integration
360      !
361      !
362      IF(.NOT.ln_linssh ) THEN
363         hu_b(:,:) = e3u_b(:,:,1) * umask(:,:,1)
364         hv_b(:,:) = e3v_b(:,:,1) * vmask(:,:,1)
365         DO jk = 2, jpkm1
366            hu_b(:,:) = hu_b(:,:) + e3u_b(:,:,jk) * umask(:,:,jk)
367            hv_b(:,:) = hv_b(:,:) + e3v_b(:,:,jk) * vmask(:,:,jk)
368         END DO
369         r1_hu_b(:,:) = ssumask(:,:) / ( hu_b(:,:) + 1._wp - ssumask(:,:) )
370         r1_hv_b(:,:) = ssvmask(:,:) / ( hv_b(:,:) + 1._wp - ssvmask(:,:) )
371      ENDIF
372      !
373      un_b(:,:) = e3u_a(:,:,1) * un(:,:,1) * umask(:,:,1)
374      ub_b(:,:) = e3u_b(:,:,1) * ub(:,:,1) * umask(:,:,1)
375      vn_b(:,:) = e3v_a(:,:,1) * vn(:,:,1) * vmask(:,:,1)
376      vb_b(:,:) = e3v_b(:,:,1) * vb(:,:,1) * vmask(:,:,1)
377      DO jk = 2, jpkm1
378         un_b(:,:) = un_b(:,:) + e3u_a(:,:,jk) * un(:,:,jk) * umask(:,:,jk)
379         ub_b(:,:) = ub_b(:,:) + e3u_b(:,:,jk) * ub(:,:,jk) * umask(:,:,jk)
380         vn_b(:,:) = vn_b(:,:) + e3v_a(:,:,jk) * vn(:,:,jk) * vmask(:,:,jk)
381         vb_b(:,:) = vb_b(:,:) + e3v_b(:,:,jk) * vb(:,:,jk) * vmask(:,:,jk)
382      END DO
383      un_b(:,:) = un_b(:,:) * r1_hu_a(:,:)
384      vn_b(:,:) = vn_b(:,:) * r1_hv_a(:,:)
385      ub_b(:,:) = ub_b(:,:) * r1_hu_b(:,:)
386      vb_b(:,:) = vb_b(:,:) * r1_hv_b(:,:)
387      !
388      IF( .NOT.ln_dynspg_ts ) THEN        ! output the barotropic currents
389         CALL iom_put(  "ubar", un_b(:,:) )
390         CALL iom_put(  "vbar", vn_b(:,:) )
391      ENDIF
392      IF( l_trddyn ) THEN                ! 3D output: asselin filter trends on momentum
393         zua(:,:,:) = ( ub(:,:,:) - zua(:,:,:) ) * z1_2dt
394         zva(:,:,:) = ( vb(:,:,:) - zva(:,:,:) ) * z1_2dt
395         CALL trd_dyn( zua, zva, jpdyn_atf, kt )
396      ENDIF
397      !
398      IF(ln_ctl)   CALL prt_ctl( tab3d_1=un, clinfo1=' nxt  - Un: ', mask1=umask,   &
399         &                       tab3d_2=vn, clinfo2=' Vn: '       , mask2=vmask )
400      !
401      IF( ln_dynspg_ts )   DEALLOCATE( zue, zve )
402      IF( l_trddyn     )   DEALLOCATE( zua, zva )
403      IF( ln_timing    )   CALL timing_stop('dyn_nxt')
404      !
405   END SUBROUTINE dyn_nxt
406
407   !!=========================================================================
408END MODULE dynnxt
Note: See TracBrowser for help on using the repository browser.