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/UKMO/NEMO_4.0.4_momentum_trends/src/OCE/DYN – NEMO

source: NEMO/branches/UKMO/NEMO_4.0.4_momentum_trends/src/OCE/DYN/dynnxt.F90 @ 15168

Last change on this file since 15168 was 15168, checked in by davestorkey, 3 years ago

UKMO/NEMO_4.0.4_momentum_trends: Introduce top friction trends (ice shelf cavities
and implicit ice-ocean drag) and reorganise bottom friction trend diagnostic.
In this version there are tfr2d, bfr2d diagnostics which are the accelerations of
the barotropic flow due to top and bottom friction, and tfr, bfr diagnostics which
are the acceleration of the baroclinic flow due to top and bottom friction (implicit
or explicit).
File size: 19.4 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   USE zdfdrg ,  ONLY : ln_drgice_imp, rCdU_top
51#if defined key_agrif
52   USE agrif_oce_interp
53#endif
54
55   IMPLICIT NONE
56   PRIVATE
57
58   PUBLIC    dyn_nxt   ! routine called by step.F90
59
60   !!----------------------------------------------------------------------
61   !! NEMO/OCE 4.0 , NEMO Consortium (2018)
62   !! $Id$
63   !! Software governed by the CeCILL license (see ./LICENSE)
64   !!----------------------------------------------------------------------
65CONTAINS
66
67   SUBROUTINE dyn_nxt ( kt )
68      !!----------------------------------------------------------------------
69      !!                  ***  ROUTINE dyn_nxt  ***
70      !!                   
71      !! ** Purpose :   Finalize after horizontal velocity. Apply the boundary
72      !!             condition on the after velocity, achieve the time stepping
73      !!             by applying the Asselin filter on now fields and swapping
74      !!             the fields.
75      !!
76      !! ** Method  : * Ensure after velocities transport matches time splitting
77      !!             estimate (ln_dynspg_ts=T)
78      !!
79      !!              * Apply lateral boundary conditions on after velocity
80      !!             at the local domain boundaries through lbc_lnk call,
81      !!             at the one-way open boundaries (ln_bdy=T),
82      !!             at the AGRIF zoom   boundaries (lk_agrif=T)
83      !!
84      !!              * Apply the time filter applied and swap of the dynamics
85      !!             arrays to start the next time step:
86      !!                (ub,vb) = (un,vn) + atfp [ (ub,vb) + (ua,va) - 2 (un,vn) ]
87      !!                (un,vn) = (ua,va).
88      !!             Note that with flux form advection and non linear free surface,
89      !!             the time filter is applied on thickness weighted velocity.
90      !!             As a result, dyn_nxt MUST be called after tra_nxt.
91      !!
92      !! ** Action :   ub,vb   filtered before horizontal velocity of next time-step
93      !!               un,vn   now horizontal velocity of next time-step
94      !!----------------------------------------------------------------------
95      INTEGER, INTENT( in ) ::   kt      ! ocean time-step index
96      !
97      INTEGER  ::   ji, jj, jk   ! dummy loop indices
98      INTEGER  ::   ikt          ! local integers
99      REAL(wp) ::   zue3a, zue3n, zue3b, zuf, zcoef    ! local scalars
100      REAL(wp) ::   zve3a, zve3n, zve3b, zvf, z1_2dt   !   -      -
101      REAL(wp), ALLOCATABLE, DIMENSION(:,:)   ::   zue, zve
102      REAL(wp), ALLOCATABLE, DIMENSION(:,:)   ::   zutau, zvtau
103      REAL(wp), ALLOCATABLE, DIMENSION(:,:,:) ::   ze3u_f, ze3v_f, zua, zva 
104      !!----------------------------------------------------------------------
105      !
106      IF( ln_timing    )   CALL timing_start('dyn_nxt')
107      IF( ln_dynspg_ts )   ALLOCATE( zue(jpi,jpj)     , zve(jpi,jpj)     )
108      IF( l_trddyn     )   ALLOCATE( zua(jpi,jpj,jpk) , zva(jpi,jpj,jpk) )
109      !
110      IF( kt == nit000 ) THEN
111         IF(lwp) WRITE(numout,*)
112         IF(lwp) WRITE(numout,*) 'dyn_nxt : time stepping'
113         IF(lwp) WRITE(numout,*) '~~~~~~~'
114      ENDIF
115
116      IF ( ln_dynspg_ts ) THEN
117         ! Ensure below that barotropic velocities match time splitting estimate
118         ! Compute actual transport and replace it with ts estimate at "after" time step
119         zue(:,:) = e3u_a(:,:,1) * ua(:,:,1) * umask(:,:,1)
120         zve(:,:) = e3v_a(:,:,1) * va(:,:,1) * vmask(:,:,1)
121         DO jk = 2, jpkm1
122            zue(:,:) = zue(:,:) + e3u_a(:,:,jk) * ua(:,:,jk) * umask(:,:,jk)
123            zve(:,:) = zve(:,:) + e3v_a(:,:,jk) * va(:,:,jk) * vmask(:,:,jk)
124         END DO
125         DO jk = 1, jpkm1
126            ua(:,:,jk) = ( ua(:,:,jk) - zue(:,:) * r1_hu_a(:,:) + ua_b(:,:) ) * umask(:,:,jk)
127            va(:,:,jk) = ( va(:,:,jk) - zve(:,:) * r1_hv_a(:,:) + va_b(:,:) ) * vmask(:,:,jk)
128         END DO
129         !
130         IF( .NOT.ln_bt_fw ) THEN
131            ! Remove advective velocity from "now velocities"
132            ! prior to asselin filtering     
133            ! In the forward case, this is done below after asselin filtering   
134            ! so that asselin contribution is removed at the same time
135            DO jk = 1, jpkm1
136               un(:,:,jk) = ( un(:,:,jk) - un_adv(:,:)*r1_hu_n(:,:) + un_b(:,:) )*umask(:,:,jk)
137               vn(:,:,jk) = ( vn(:,:,jk) - vn_adv(:,:)*r1_hv_n(:,:) + vn_b(:,:) )*vmask(:,:,jk)
138            END DO 
139         ENDIF
140      ENDIF
141
142      ! Update after velocity on domain lateral boundaries
143      ! --------------------------------------------------     
144# if defined key_agrif
145      CALL Agrif_dyn( kt )             !* AGRIF zoom boundaries
146# endif
147      !
148      CALL lbc_lnk_multi( 'dynnxt', ua, 'U', -1., va, 'V', -1. )     !* local domain boundaries
149      !
150      !                                !* BDY open boundaries
151      IF( ln_bdy .AND. ln_dynspg_exp )   CALL bdy_dyn( kt )
152      IF( ln_bdy .AND. ln_dynspg_ts  )   CALL bdy_dyn( kt, dyn3d_only=.true. )
153
154!!$   Do we need a call to bdy_vol here??
155      !
156      IF( l_trddyn ) THEN             ! prepare the atf trend computation + some diagnostics
157         z1_2dt = 1._wp / (2. * rdt)        ! Euler or leap-frog time step
158         IF( neuler == 0 .AND. kt == nit000 )   z1_2dt = 1._wp / rdt
159         !
160         !                                  ! Kinetic energy and Conversion
161         IF( ln_KE_trd  )   CALL trd_dyn( ua, va, jpdyn_ken, kt )
162         !
163         IF( ln_dyn_trd ) THEN              ! 3D output: total momentum trends
164            zua(:,:,:) = ( ua(:,:,:) - ub(:,:,:) ) * z1_2dt
165            zva(:,:,:) = ( va(:,:,:) - vb(:,:,:) ) * z1_2dt
166            CALL trd_dyn( zua, zva, jpdyn_tot, kt )  ! total momentum trends, except the asselin time filter
167!!$            CALL iom_put( "utrd_tot", zua )        ! total momentum trends, except the asselin time filter
168!!$            CALL iom_put( "vtrd_tot", zva )
169         ENDIF
170         !
171         zua(:,:,:) = un(:,:,:)             ! save the now velocity before the asselin filter
172         zva(:,:,:) = vn(:,:,:)             ! (caution: there will be a shift by 1 timestep in the
173         !                                  !  computation of the asselin filter trends)
174      ENDIF
175
176      ! Time filter and swap of dynamics arrays
177      ! ------------------------------------------
178      IF( neuler == 0 .AND. kt == nit000 ) THEN        !* Euler at first time-step: only swap
179         DO jk = 1, jpkm1
180            ub(:,:,jk) = un(:,:,jk)                         ! ub <-- un
181            vb(:,:,jk) = vn(:,:,jk)
182            un(:,:,jk) = ua(:,:,jk)                         ! un <-- ua
183            vn(:,:,jk) = va(:,:,jk)
184         END DO
185         IF( .NOT.ln_linssh ) THEN                          ! e3._b <-- e3._n
186!!gm BUG ????    I don't understand why it is not : e3._n <-- e3._a 
187            DO jk = 1, jpkm1
188!               e3t_b(:,:,jk) = e3t_n(:,:,jk)
189!               e3u_b(:,:,jk) = e3u_n(:,:,jk)
190!               e3v_b(:,:,jk) = e3v_n(:,:,jk)
191               !
192               e3t_n(:,:,jk) = e3t_a(:,:,jk)
193               e3u_n(:,:,jk) = e3u_a(:,:,jk)
194               e3v_n(:,:,jk) = e3v_a(:,:,jk)
195            END DO
196!!gm BUG end
197         ENDIF
198                                                            !
199         
200      ELSE                                             !* Leap-Frog : Asselin filter and swap
201         !                                ! =============!
202         IF( ln_linssh ) THEN             ! Fixed volume !
203            !                             ! =============!
204            DO jk = 1, jpkm1                             
205               DO jj = 1, jpj
206                  DO ji = 1, jpi   
207                     zuf = un(ji,jj,jk) + atfp * ( ub(ji,jj,jk) - 2._wp * un(ji,jj,jk) + ua(ji,jj,jk) )
208                     zvf = vn(ji,jj,jk) + atfp * ( vb(ji,jj,jk) - 2._wp * vn(ji,jj,jk) + va(ji,jj,jk) )
209                     !
210                     ub(ji,jj,jk) = zuf                      ! ub <-- filtered velocity
211                     vb(ji,jj,jk) = zvf
212                     un(ji,jj,jk) = ua(ji,jj,jk)             ! un <-- ua
213                     vn(ji,jj,jk) = va(ji,jj,jk)
214                  END DO
215               END DO
216            END DO
217            !                             ! ================!
218         ELSE                             ! Variable volume !
219            !                             ! ================!
220            ! Before scale factor at t-points
221            ! (used as a now filtered scale factor until the swap)
222            ! ----------------------------------------------------
223            DO jk = 1, jpkm1
224               e3t_b(:,:,jk) = e3t_n(:,:,jk) + atfp * ( e3t_b(:,:,jk) - 2._wp * e3t_n(:,:,jk) + e3t_a(:,:,jk) )
225            END DO
226            ! Add volume filter correction: compatibility with tracer advection scheme
227            ! => time filter + conservation correction (only at the first level)
228            zcoef = atfp * rdt * r1_rau0
229
230            DO jk = 1, jpkm1
231               e3t_b(:,:,jk) = e3t_b(:,:,jk) - zcoef * ( emp_b(:,:) - emp(:,:) ) * tmask(:,:,jk) & 
232                             &                       * e3t_n(:,:,jk) /  ( ht_n(:,:) + 1._wp - ssmask(:,:) )
233            END DO
234
235            IF ( ln_rnf ) THEN
236               DO jk = 1, jpkm1
237                  e3t_b(:,:,jk) = e3t_b(:,:,jk) + zcoef * ( rnf_b(:,:) - rnf(:,:) ) * tmask(:,:,jk) & 
238                                &                       * e3t_n(:,:,jk) /  ( ht_n(:,:) + 1._wp - ssmask(:,:) )
239               END DO
240            ENDIF
241
242            IF ( ln_isf ) THEN
243               DO jk = 1, jpkm1
244                  e3t_b(:,:,jk) = e3t_b(:,:,jk) - zcoef * ( fwfisf_b(:,:) - fwfisf(:,:) ) * tmask(:,:,jk) & 
245                                &                       * e3t_n(:,:,jk) /  ( ht_n(:,:) + 1._wp - ssmask(:,:) )
246               END DO
247            ENDIF
248            !
249            IF( ln_dynadv_vec ) THEN      ! Asselin filter applied on velocity
250               ! Before filtered scale factor at (u/v)-points
251               CALL dom_vvl_interpol( e3t_b(:,:,:), e3u_b(:,:,:), 'U' )
252               CALL dom_vvl_interpol( e3t_b(:,:,:), e3v_b(:,:,:), 'V' )
253               DO jk = 1, jpkm1
254                  DO jj = 1, jpj
255                     DO ji = 1, jpi
256                        zuf = un(ji,jj,jk) + atfp * ( ub(ji,jj,jk) - 2._wp * un(ji,jj,jk) + ua(ji,jj,jk) )
257                        zvf = vn(ji,jj,jk) + atfp * ( vb(ji,jj,jk) - 2._wp * vn(ji,jj,jk) + va(ji,jj,jk) )
258                        !
259                        ub(ji,jj,jk) = zuf                      ! ub <-- filtered velocity
260                        vb(ji,jj,jk) = zvf
261                        un(ji,jj,jk) = ua(ji,jj,jk)             ! un <-- ua
262                        vn(ji,jj,jk) = va(ji,jj,jk)
263                     END DO
264                  END DO
265               END DO
266               !
267            ELSE                          ! Asselin filter applied on thickness weighted velocity
268               !
269               ALLOCATE( ze3u_f(jpi,jpj,jpk) , ze3v_f(jpi,jpj,jpk) )
270               ! Before filtered scale factor at (u/v)-points stored in ze3u_f, ze3v_f
271               CALL dom_vvl_interpol( e3t_b(:,:,:), ze3u_f, 'U' )
272               CALL dom_vvl_interpol( e3t_b(:,:,:), ze3v_f, 'V' )
273               DO jk = 1, jpkm1
274                  DO jj = 1, jpj
275                     DO ji = 1, jpi                 
276                        zue3a = e3u_a(ji,jj,jk) * ua(ji,jj,jk)
277                        zve3a = e3v_a(ji,jj,jk) * va(ji,jj,jk)
278                        zue3n = e3u_n(ji,jj,jk) * un(ji,jj,jk)
279                        zve3n = e3v_n(ji,jj,jk) * vn(ji,jj,jk)
280                        zue3b = e3u_b(ji,jj,jk) * ub(ji,jj,jk)
281                        zve3b = e3v_b(ji,jj,jk) * vb(ji,jj,jk)
282                        !
283                        zuf = ( zue3n + atfp * ( zue3b - 2._wp * zue3n  + zue3a ) ) / ze3u_f(ji,jj,jk)
284                        zvf = ( zve3n + atfp * ( zve3b - 2._wp * zve3n  + zve3a ) ) / ze3v_f(ji,jj,jk)
285                        !
286                        ub(ji,jj,jk) = zuf                     ! ub <-- filtered velocity
287                        vb(ji,jj,jk) = zvf
288                        un(ji,jj,jk) = ua(ji,jj,jk)            ! un <-- ua
289                        vn(ji,jj,jk) = va(ji,jj,jk)
290                     END DO
291                  END DO
292               END DO
293               e3u_b(:,:,1:jpkm1) = ze3u_f(:,:,1:jpkm1)        ! e3u_b <-- filtered scale factor
294               e3v_b(:,:,1:jpkm1) = ze3v_f(:,:,1:jpkm1)
295               !
296               DEALLOCATE( ze3u_f , ze3v_f )
297            ENDIF
298            !
299         ENDIF
300         !
301         IF( ln_dynspg_ts .AND. ln_bt_fw ) THEN
302            ! Revert "before" velocities to time split estimate
303            ! Doing it here also means that asselin filter contribution is removed 
304            zue(:,:) = e3u_b(:,:,1) * ub(:,:,1) * umask(:,:,1)
305            zve(:,:) = e3v_b(:,:,1) * vb(:,:,1) * vmask(:,:,1)   
306            DO jk = 2, jpkm1
307               zue(:,:) = zue(:,:) + e3u_b(:,:,jk) * ub(:,:,jk) * umask(:,:,jk)
308               zve(:,:) = zve(:,:) + e3v_b(:,:,jk) * vb(:,:,jk) * vmask(:,:,jk)   
309            END DO
310            DO jk = 1, jpkm1
311               ub(:,:,jk) = ub(:,:,jk) - (zue(:,:) * r1_hu_n(:,:) - un_b(:,:)) * umask(:,:,jk)
312               vb(:,:,jk) = vb(:,:,jk) - (zve(:,:) * r1_hv_n(:,:) - vn_b(:,:)) * vmask(:,:,jk)
313            END DO
314         ENDIF
315         !
316      ENDIF ! neuler =/0
317      !
318      ! Set "now" and "before" barotropic velocities for next time step:
319      ! JC: Would be more clever to swap variables than to make a full vertical
320      ! integration
321      !
322      !
323      IF(.NOT.ln_linssh ) THEN
324         hu_b(:,:) = e3u_b(:,:,1) * umask(:,:,1)
325         hv_b(:,:) = e3v_b(:,:,1) * vmask(:,:,1)
326         DO jk = 2, jpkm1
327            hu_b(:,:) = hu_b(:,:) + e3u_b(:,:,jk) * umask(:,:,jk)
328            hv_b(:,:) = hv_b(:,:) + e3v_b(:,:,jk) * vmask(:,:,jk)
329         END DO
330         r1_hu_b(:,:) = ssumask(:,:) / ( hu_b(:,:) + 1._wp - ssumask(:,:) )
331         r1_hv_b(:,:) = ssvmask(:,:) / ( hv_b(:,:) + 1._wp - ssvmask(:,:) )
332      ENDIF
333      !
334      un_b(:,:) = e3u_a(:,:,1) * un(:,:,1) * umask(:,:,1)
335      ub_b(:,:) = e3u_b(:,:,1) * ub(:,:,1) * umask(:,:,1)
336      vn_b(:,:) = e3v_a(:,:,1) * vn(:,:,1) * vmask(:,:,1)
337      vb_b(:,:) = e3v_b(:,:,1) * vb(:,:,1) * vmask(:,:,1)
338      DO jk = 2, jpkm1
339         un_b(:,:) = un_b(:,:) + e3u_a(:,:,jk) * un(:,:,jk) * umask(:,:,jk)
340         ub_b(:,:) = ub_b(:,:) + e3u_b(:,:,jk) * ub(:,:,jk) * umask(:,:,jk)
341         vn_b(:,:) = vn_b(:,:) + e3v_a(:,:,jk) * vn(:,:,jk) * vmask(:,:,jk)
342         vb_b(:,:) = vb_b(:,:) + e3v_b(:,:,jk) * vb(:,:,jk) * vmask(:,:,jk)
343      END DO
344      un_b(:,:) = un_b(:,:) * r1_hu_a(:,:)
345      vn_b(:,:) = vn_b(:,:) * r1_hv_a(:,:)
346      ub_b(:,:) = ub_b(:,:) * r1_hu_b(:,:)
347      vb_b(:,:) = vb_b(:,:) * r1_hv_b(:,:)
348      !
349      IF( .NOT.ln_dynspg_ts ) THEN        ! output the barotropic currents
350         CALL iom_put(  "ubar", un_b(:,:) )
351         CALL iom_put(  "vbar", vn_b(:,:) )
352      ENDIF
353      IF( l_trddyn ) THEN                ! 3D output: asselin filter trends on momentum
354         zua(:,:,:) = ( ub(:,:,:) - zua(:,:,:) ) * z1_2dt
355         zva(:,:,:) = ( vb(:,:,:) - zva(:,:,:) ) * z1_2dt
356         CALL trd_dyn( zua, zva, jpdyn_atf, kt )
357      ENDIF
358      !
359      IF ( iom_use("utau") ) THEN
360         IF ( ln_drgice_imp.OR.ln_isfcav ) THEN
361            ALLOCATE(zutau(jpi,jpj)) 
362            DO jj = 2, jpjm1
363               DO ji = 2, jpim1
364                  jk = miku(ji,jj) 
365                  zutau(ji,jj) = utau(ji,jj) & 
366                  &  + 0.5_wp * rau0 * (rCdU_top(ji+1,jj)+rCdU_top(ji,jj)) * ua(ji,jj,jk) 
367               END DO
368            END DO
369            CALL lbc_lnk( 'dynnxt' , zutau, 'U', -1.)
370            CALL iom_put(  "utau", zutau(:,:) )
371            DEALLOCATE(zutau)
372         ELSE
373            CALL iom_put(  "utau", utau(:,:) )
374         ENDIF
375      ENDIF
376      !
377      IF ( iom_use("vtau") ) THEN
378         IF ( ln_drgice_imp.OR.ln_isfcav ) THEN
379            ALLOCATE(zvtau(jpi,jpj))
380            DO jj = 2, jpjm1
381               DO ji = 2, jpim1
382                  jk = mikv(ji,jj)
383                  zvtau(ji,jj) = vtau(ji,jj) &
384                  &  + 0.5_wp * rau0 * (rCdU_top(ji,jj+1)+rCdU_top(ji,jj)) * va(ji,jj,jk)
385               END DO
386            END DO
387            CALL lbc_lnk( 'dynnxt' , zvtau, 'V', -1.)
388            CALL iom_put(  "vtau", zvtau(:,:) )
389            DEALLOCATE(zvtau)
390         ELSE
391            CALL iom_put(  "vtau", vtau(:,:) )
392         ENDIF
393      ENDIF
394      !
395      IF(ln_ctl)   CALL prt_ctl( tab3d_1=un, clinfo1=' nxt  - Un: ', mask1=umask,   &
396         &                       tab3d_2=vn, clinfo2=' Vn: '       , mask2=vmask )
397      !
398      IF( ln_dynspg_ts )   DEALLOCATE( zue, zve )
399      IF( l_trddyn     )   DEALLOCATE( zua, zva )
400      IF( ln_timing    )   CALL timing_stop('dyn_nxt')
401      !
402   END SUBROUTINE dyn_nxt
403
404   !!=========================================================================
405END MODULE dynnxt
Note: See TracBrowser for help on using the repository browser.