source: NEMO/branches/2019/dev_r10721_KERNEL-02_Storkey_Coward_IMMERSE_first_steps_rewrite_time_filterswap/src/OCE/DYN/dynatf.F90 @ 11050

Last change on this file since 11050 was 11050, checked in by davestorkey, 17 months ago

2019/dev_r10721_KERNEL-02_Storkey_Coward_IMMERSE_first_steps_rewrite_time_filterswap : Rewrite dynnxt.F90 and rename dynatf.F90 with time level swapping in stp. This doesn't work yet but committing for the record before I merge in Andrew's changes to the main branch.

  • Property svn:keywords set to Id
File size: 18.7 KB
Line 
1MODULE dynatf
2   !!=========================================================================
3   !!                       ***  MODULE  dynatf  ***
4   !! Ocean dynamics: time filtering
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   !!            4.1  !  2019-05  (D. Storkey) Rename dynnxt -> dynatf. Now just does time filtering.
23   !!-------------------------------------------------------------------------
24 
25   !!----------------------------------------------------------------------------------------------
26   !!   dyn_atf       : apply Asselin time filtering to "now" velocities and vertical scale factors
27   !!----------------------------------------------------------------------------------------------
28   USE oce            ! ocean dynamics and tracers
29   USE dom_oce        ! ocean space and time domain
30   USE sbc_oce        ! Surface boundary condition: ocean fields
31   USE sbcrnf         ! river runoffs
32   USE sbcisf         ! ice shelf
33   USE phycst         ! physical constants
34   USE dynadv         ! dynamics: vector invariant versus flux form
35   USE dynspg_ts      ! surface pressure gradient: split-explicit scheme
36   USE domvvl         ! variable volume
37   USE bdy_oce   , ONLY: ln_bdy
38   USE bdydta         ! ocean open boundary conditions
39   USE bdydyn         ! ocean open boundary conditions
40   USE bdyvol         ! ocean open boundary condition (bdy_vol routines)
41   USE trd_oce        ! trends: ocean variables
42   USE trddyn         ! trend manager: dynamics
43   USE trdken         ! trend manager: kinetic energy
44   !
45   USE in_out_manager ! I/O manager
46   USE iom            ! I/O manager library
47   USE lbclnk         ! lateral boundary condition (or mpp link)
48   USE lib_mpp        ! MPP library
49   USE prtctl         ! Print control
50   USE timing         ! Timing
51#if defined key_agrif
52   USE agrif_oce_interp
53#endif
54
55   IMPLICIT NONE
56   PRIVATE
57
58   PUBLIC    dyn_atf   ! 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_atf ( kt, Kbb, Kmm, Kaa, puu, pvv, pe3t, pe3u, pe3v )
68      !!----------------------------------------------------------------------
69      !!                  ***  ROUTINE dyn_atf  ***
70      !!                   
71      !!  !!!!!!!!!!!!!!!!!!  REWRITE HEADER COMMENTS !!!!!!!!!!!!!!!!!
72      !!
73      !! ** Purpose :   Finalize after horizontal velocity. Apply the boundary
74      !!             condition on the after velocity, achieve the time stepping
75      !!             by applying the Asselin filter on now fields and swapping
76      !!             the fields.
77      !!
78      !! ** Method  : * Ensure after velocities transport matches time splitting
79      !!             estimate (ln_dynspg_ts=T)
80      !!
81      !!              * Apply lateral boundary conditions on after velocity
82      !!             at the local domain boundaries through lbc_lnk call,
83      !!             at the one-way open boundaries (ln_bdy=T),
84      !!             at the AGRIF zoom   boundaries (lk_agrif=T)
85      !!
86      !!              * Apply the time filter applied and swap of the dynamics
87      !!             arrays to start the next time step:
88      !!                (puu(:,:,:,Kbb),pvv(:,:,:,Kbb)) = (puu(:,:,:,Kmm),pvv(:,:,:,Kmm)) + atfp [ (puu(:,:,:,Kbb),pvv(:,:,:,Kbb)) + (puu(:,:,:,Kaa),pvv(:,:,:,Kaa)) - 2 (puu(:,:,:,Kmm),pvv(:,:,:,Kmm)) ]
89      !!                (puu(:,:,:,Kmm),pvv(:,:,:,Kmm)) = (puu(:,:,:,Kaa),pvv(:,:,:,Kaa)).
90      !!             Note that with flux form advection and non linear free surface,
91      !!             the time filter is applied on thickness weighted velocity.
92      !!             As a result, dyn_atf MUST be called after tra_nxt.
93      !!
94      !! ** Action :   uu(Kmm),vv(Kmm)   filtered now horizontal velocity
95      !!----------------------------------------------------------------------
96      INTEGER                             , INTENT(in   ) :: kt               ! ocean time-step index
97      INTEGER                             , INTENT(in   ) :: Kbb, Kmm, Kaa    ! before and after time level indices
98      REAL(wp), DIMENSION(jpi,jpj,jpk,jpt), INTENT(inout) :: puu, pvv         ! velocities to be time filtered
99      REAL(wp), DIMENSION(jpi,jpj,jpk,jpt), INTENT(inout) :: pe3t, pe3u, pe3v ! scale factors to be time filtered
100      !
101      INTEGER  ::   ji, jj, jk   ! dummy loop indices
102      REAL(wp) ::   zue3a, zue3n, zue3b, zcoef    ! local scalars
103      REAL(wp) ::   zve3a, zve3n, zve3b, z1_2dt   !   -      -
104      REAL(wp), ALLOCATABLE, DIMENSION(:,:)   ::   zue, zve
105      REAL(wp), ALLOCATABLE, DIMENSION(:,:,:) ::   ze3t_f, ze3u_f, ze3v_f, zua, zva 
106      !!----------------------------------------------------------------------
107      !
108      IF( ln_timing    )   CALL timing_start('dyn_atf')
109      IF( ln_dynspg_ts )   ALLOCATE( zue(jpi,jpj)     , zve(jpi,jpj)     )
110      IF( l_trddyn     )   ALLOCATE( zua(jpi,jpj,jpk) , zva(jpi,jpj,jpk) )
111      !
112      IF( kt == nit000 ) THEN
113         IF(lwp) WRITE(numout,*)
114         IF(lwp) WRITE(numout,*) 'dyn_atf : Asselin time filtering'
115         IF(lwp) WRITE(numout,*) '~~~~~~~'
116      ENDIF
117
118      IF ( ln_dynspg_ts ) THEN
119         ! Ensure below that barotropic velocities match time splitting estimate
120         ! Compute actual transport and replace it with ts estimate at "after" time step
121         zue(:,:) = pe3u(:,:,1,Kaa) * puu(:,:,1,Kaa) * umask(:,:,1)
122         zve(:,:) = pe3v(:,:,1,Kaa) * pvv(:,:,1,Kaa) * vmask(:,:,1)
123         DO jk = 2, jpkm1
124            zue(:,:) = zue(:,:) + pe3u(:,:,jk,Kaa) * puu(:,:,jk,Kaa) * umask(:,:,jk)
125            zve(:,:) = zve(:,:) + pe3v(:,:,jk,Kaa) * pvv(:,:,jk,Kaa) * vmask(:,:,jk)
126         END DO
127         DO jk = 1, jpkm1
128            puu(:,:,jk,Kaa) = ( puu(:,:,jk,Kaa) - zue(:,:) * r1_hu(:,:,Kaa) + uu_b(:,:,Kaa) ) * umask(:,:,jk)
129            pvv(:,:,jk,Kaa) = ( pvv(:,:,jk,Kaa) - zve(:,:) * r1_hv(:,:,Kaa) + vv_b(:,:,Kaa) ) * vmask(:,:,jk)
130         END DO
131         !
132         IF( .NOT.ln_bt_fw ) THEN
133            ! Remove advective velocity from "now velocities"
134            ! prior to asselin filtering     
135            ! In the forward case, this is done below after asselin filtering   
136            ! so that asselin contribution is removed at the same time
137            DO jk = 1, jpkm1
138               puu(:,:,jk,Kmm) = ( puu(:,:,jk,Kmm) - un_adv(:,:)*r1_hu(:,:,Kmm) + uu_b(:,:,Kmm) )*umask(:,:,jk)
139               pvv(:,:,jk,Kmm) = ( pvv(:,:,jk,Kmm) - vn_adv(:,:)*r1_hv(:,:,Kmm) + vv_b(:,:,Kmm) )*vmask(:,:,jk)
140            END DO 
141         ENDIF
142      ENDIF
143
144      ! Update after velocity on domain lateral boundaries
145      ! --------------------------------------------------     
146# if defined key_agrif
147      CALL Agrif_dyn( kt )             !* AGRIF zoom boundaries
148# endif
149      !
150      CALL lbc_lnk_multi( 'dynnxt', puu(:,:,:,Kaa), 'U', -1., pvv(:,:,:,Kaa), 'V', -1. )     !* local domain boundaries
151      !
152      !                                !* BDY open boundaries
153      IF( ln_bdy .AND. ln_dynspg_exp )   CALL bdy_dyn( kt, Kbb, puu, pvv, Kaa )
154      IF( ln_bdy .AND. ln_dynspg_ts  )   CALL bdy_dyn( kt, Kbb, puu, pvv, Kaa, dyn3d_only=.true. )
155
156!!$   Do we need a call to bdy_vol here??
157      !
158      IF( l_trddyn ) THEN             ! prepare the atf trend computation + some diagnostics
159         z1_2dt = 1._wp / (2. * rdt)        ! Euler or leap-frog time step
160         IF( neuler == 0 .AND. kt == nit000 )   z1_2dt = 1._wp / rdt
161         !
162         !                                  ! Kinetic energy and Conversion
163         IF( ln_KE_trd  )   CALL trd_dyn( puu(:,:,:,Kaa), pvv(:,:,:,Kaa), jpdyn_ken, kt, Kmm )
164         !
165         IF( ln_dyn_trd ) THEN              ! 3D output: total momentum trends
166            zua(:,:,:) = ( puu(:,:,:,Kaa) - puu(:,:,:,Kbb) ) * z1_2dt
167            zva(:,:,:) = ( pvv(:,:,:,Kaa) - pvv(:,:,:,Kbb) ) * z1_2dt
168            CALL iom_put( "utrd_tot", zua )        ! total momentum trends, except the asselin time filter
169            CALL iom_put( "vtrd_tot", zva )
170         ENDIF
171         !
172         zua(:,:,:) = puu(:,:,:,Kmm)             ! save the now velocity before the asselin filter
173         zva(:,:,:) = pvv(:,:,:,Kmm)             ! (caution: there will be a shift by 1 timestep in the
174         !                                  !  computation of the asselin filter trends)
175      ENDIF
176
177      ! Time filter and swap of dynamics arrays
178      ! ------------------------------------------
179         
180      IF( .NOT.( neuler == 0 .AND. kt == nit000 ) ) THEN    !* Leap-Frog : Asselin time filter
181         !                                ! =============!
182         IF( ln_linssh ) THEN             ! Fixed volume !
183            !                             ! =============!
184            DO jk = 1, jpkm1                             
185               DO jj = 1, jpj
186                  DO ji = 1, jpi   
187                     puu(ji,jj,jk,Kmm) = puu(ji,jj,jk,Kmm) + atfp * ( puu(ji,jj,jk,Kbb) - 2._wp * puu(ji,jj,jk,Kmm) + puu(ji,jj,jk,Kaa) )
188                     pvv(ji,jj,jk,Kmm) = pvv(ji,jj,jk,Kmm) + atfp * ( pvv(ji,jj,jk,Kbb) - 2._wp * pvv(ji,jj,jk,Kmm) + pvv(ji,jj,jk,Kaa) )
189                  END DO
190               END DO
191            END DO
192            !                             ! ================!
193         ELSE                             ! Variable volume !
194            !                             ! ================!
195            ! Time-filtered scale factor at t-points
196            ! ----------------------------------------------------
197            ALLOCATE( ze3t_f(jpi,jpj,jpk) )
198            DO jk = 1, jpkm1
199               ze3t_f(:,:,jk) = pe3t(:,:,jk,Kmm) + atfp * ( pe3t(:,:,jk,Kbb) - 2._wp * pe3t(:,:,jk,Kmm) + pe3t(:,:,jk,Kaa) )
200            END DO
201            ! Add volume filter correction: compatibility with tracer advection scheme
202            ! => time filter + conservation correction (only at the first level)
203            zcoef = atfp * rdt * r1_rau0
204
205            ze3t_f(:,:,1) = ze3t_f(:,:,1) - zcoef * ( emp_b(:,:) - emp(:,:) ) * tmask(:,:,1)
206
207            IF ( ln_rnf ) THEN
208               IF( ln_rnf_depth ) THEN
209                  DO jk = 1, jpkm1 ! Deal with Rivers separately, as can be through depth too
210                     DO jj = 1, jpj
211                        DO ji = 1, jpi
212                           IF( jk <=  nk_rnf(ji,jj)  ) THEN
213                               ze3t_f(ji,jj,jk) =   ze3t_f(ji,jj,jk) - zcoef *  ( - rnf_b(ji,jj) + rnf(ji,jj) ) &
214                                      &          * ( pe3t(ji,jj,jk,Kmm) / h_rnf(ji,jj) ) * tmask(ji,jj,jk)
215                           ENDIF
216                        ENDDO
217                     ENDDO
218                  ENDDO
219               ELSE
220                  ze3t_f(:,:,1) = ze3t_f(:,:,1) - zcoef *  ( -rnf_b(:,:) + rnf(:,:))*tmask(:,:,1)
221               ENDIF
222            END IF
223
224            IF ( ln_isf ) THEN   ! if ice shelf melting
225               DO jk = 1, jpkm1 ! Deal with isf separetely, as can be through depth too
226                  DO jj = 1, jpj
227                     DO ji = 1, jpi
228                        IF( misfkt(ji,jj) <=jk .and. jk < misfkb(ji,jj)  ) THEN
229                           ze3t_f(ji,jj,jk) = ze3t_f(ji,jj,jk) - zcoef * ( fwfisf_b(ji,jj) - fwfisf(ji,jj) ) &
230                                &          * ( pe3t(ji,jj,jk,Kmm) * r1_hisf_tbl(ji,jj) ) * tmask(ji,jj,jk)
231                        ELSEIF ( jk==misfkb(ji,jj) ) THEN
232                           ze3t_f(ji,jj,jk) = ze3t_f(ji,jj,jk) - zcoef * ( fwfisf_b(ji,jj) - fwfisf(ji,jj) ) &
233                                &          * ( pe3t(ji,jj,jk,Kmm) * r1_hisf_tbl(ji,jj) ) * ralpha(ji,jj) * tmask(ji,jj,jk)
234                        ENDIF
235                     END DO
236                  END DO
237               END DO
238            END IF
239            !
240            pe3t(:,:,1:jpkm1,Kmm) = ze3t_f(:,:,1:jpkm1)        ! filtered scale factor at T-points
241            !
242            IF( ln_dynadv_vec ) THEN      ! Asselin filter applied on velocity
243               ! Before filtered scale factor at (u/v)-points
244               CALL dom_vvl_interpol( pe3t(:,:,:,Kmm), pe3u(:,:,:,Kmm), 'U' )
245               CALL dom_vvl_interpol( pe3t(:,:,:,Kmm), pe3v(:,:,:,Kmm), 'V' )
246               DO jk = 1, jpkm1
247                  DO jj = 1, jpj
248                     DO ji = 1, jpi
249                        puu(ji,jj,jk,Kmm) = puu(ji,jj,jk,Kmm) + atfp * ( puu(ji,jj,jk,Kbb) - 2._wp * puu(ji,jj,jk,Kmm) + puu(ji,jj,jk,Kaa) )
250                        pvv(ji,jj,jk,Kmm) = pvv(ji,jj,jk,Kmm) + atfp * ( pvv(ji,jj,jk,Kbb) - 2._wp * pvv(ji,jj,jk,Kmm) + pvv(ji,jj,jk,Kaa) )
251                     END DO
252                  END DO
253               END DO
254               !
255            ELSE                          ! Asselin filter applied on thickness weighted velocity
256               !
257               ALLOCATE( ze3u_f(jpi,jpj,jpk) , ze3v_f(jpi,jpj,jpk) )
258               ! Now filtered scale factor at (u/v)-points stored in ze3u_f, ze3v_f
259               CALL dom_vvl_interpol( pe3t(:,:,:,Kmm), ze3u_f, 'U' )
260               CALL dom_vvl_interpol( pe3t(:,:,:,Kmm), ze3v_f, 'V' )
261               DO jk = 1, jpkm1
262                  DO jj = 1, jpj
263                     DO ji = 1, jpi                 
264                        zue3a = pe3u(ji,jj,jk,Kaa) * puu(ji,jj,jk,Kaa)
265                        zve3a = pe3v(ji,jj,jk,Kaa) * pvv(ji,jj,jk,Kaa)
266                        zue3n = pe3u(ji,jj,jk,Kmm) * puu(ji,jj,jk,Kmm)
267                        zve3n = pe3v(ji,jj,jk,Kmm) * pvv(ji,jj,jk,Kmm)
268                        zue3b = pe3u(ji,jj,jk,Kbb) * puu(ji,jj,jk,Kbb)
269                        zve3b = pe3v(ji,jj,jk,Kbb) * pvv(ji,jj,jk,Kbb)
270                        !
271                        puu(ji,jj,jk,Kmm) = ( zue3n + atfp * ( zue3b - 2._wp * zue3n  + zue3a ) ) / ze3u_f(ji,jj,jk)
272                        pvv(ji,jj,jk,Kmm) = ( zve3n + atfp * ( zve3b - 2._wp * zve3n  + zve3a ) ) / ze3v_f(ji,jj,jk)
273                     END DO
274                  END DO
275               END DO
276               pe3u(:,:,1:jpkm1,Kmm) = ze3u_f(:,:,1:jpkm1) 
277               pe3v(:,:,1:jpkm1,Kmm) = ze3v_f(:,:,1:jpkm1)
278               !
279               DEALLOCATE( ze3u_f , ze3v_f )
280            ENDIF
281            !
282            DEALLOCATE( ze3t_f )
283         ENDIF
284         !
285         IF( ln_dynspg_ts .AND. ln_bt_fw ) THEN
286            ! Revert filtered "now" velocities to time split estimate
287            ! Doing it here also means that asselin filter contribution is removed 
288            zue(:,:) = pe3u(:,:,1,Kmm) * puu(:,:,1,Kmm) * umask(:,:,1)
289            zve(:,:) = pe3v(:,:,1,Kmm) * pvv(:,:,1,Kmm) * vmask(:,:,1)   
290            DO jk = 2, jpkm1
291               zue(:,:) = zue(:,:) + pe3u(:,:,jk,Kmm) * puu(:,:,jk,Kmm) * umask(:,:,jk)
292               zve(:,:) = zve(:,:) + pe3v(:,:,jk,Kmm) * pvv(:,:,jk,Kmm) * vmask(:,:,jk)   
293            END DO
294            DO jk = 1, jpkm1
295               puu(:,:,jk,Kmm) = puu(:,:,jk,Kmm) - (zue(:,:) * r1_hu(:,:,Kmm) - uu_b(:,:,Kmm)) * umask(:,:,jk)
296               pvv(:,:,jk,Kmm) = pvv(:,:,jk,Kmm) - (zve(:,:) * r1_hv(:,:,Kmm) - vv_b(:,:,Kmm)) * vmask(:,:,jk)
297            END DO
298         ENDIF
299         !
300      ENDIF ! neuler /= 0
301      !
302      ! Set "now" and "before" barotropic velocities for next time step:
303      ! JC: Would be more clever to swap variables than to make a full vertical
304      ! integration
305      !
306      IF(.NOT.ln_linssh ) THEN
307         hu(:,:,Kmm) = pe3u(:,:,1,Kmm ) * umask(:,:,1)
308         hv(:,:,Kmm) = pe3v(:,:,1,Kmm ) * vmask(:,:,1)
309         DO jk = 2, jpkm1
310            hu(:,:,Kmm) = hu(:,:,Kmm) + pe3u(:,:,jk,Kmm ) * umask(:,:,jk)
311            hv(:,:,Kmm) = hv(:,:,Kmm) + pe3v(:,:,jk,Kmm ) * vmask(:,:,jk)
312         END DO
313         r1_hu(:,:,Kmm) = ssumask(:,:) / ( hu(:,:,Kmm) + 1._wp - ssumask(:,:) )
314         r1_hv(:,:,Kmm) = ssvmask(:,:) / ( hv(:,:,Kmm) + 1._wp - ssvmask(:,:) )
315      ENDIF
316      !
317      uu_b(:,:,Kaa) = pe3u(:,:,1,Kaa) * puu(:,:,1,Kaa) * umask(:,:,1)
318      uu_b(:,:,Kmm) = pe3u(:,:,1,Kmm) * puu(:,:,1,Kmm) * umask(:,:,1)
319      vv_b(:,:,Kaa) = pe3v(:,:,1,Kaa) * pvv(:,:,1,Kaa) * vmask(:,:,1)
320      vv_b(:,:,Kmm) = pe3v(:,:,1,Kmm) * pvv(:,:,1,Kmm) * vmask(:,:,1)
321      DO jk = 2, jpkm1
322         uu_b(:,:,Kaa) = uu_b(:,:,Kaa) + pe3u(:,:,jk,Kaa) * puu(:,:,jk,Kaa) * umask(:,:,jk)
323         uu_b(:,:,Kmm) = uu_b(:,:,Kmm) + pe3u(:,:,jk,Kmm) * puu(:,:,jk,Kmm) * umask(:,:,jk)
324         vv_b(:,:,Kaa) = vv_b(:,:,Kaa) + pe3v(:,:,jk,Kaa) * pvv(:,:,jk,Kaa) * vmask(:,:,jk)
325         vv_b(:,:,Kmm) = vv_b(:,:,Kmm) + pe3v(:,:,jk,Kmm) * pvv(:,:,jk,Kmm) * vmask(:,:,jk)
326      END DO
327      uu_b(:,:,Kaa) = uu_b(:,:,Kaa) * r1_hu(:,:,Kaa)
328      vv_b(:,:,Kaa) = vv_b(:,:,Kaa) * r1_hv(:,:,Kaa)
329      uu_b(:,:,Kmm) = uu_b(:,:,Kmm) * r1_hu(:,:,Kmm)
330      vv_b(:,:,Kmm) = vv_b(:,:,Kmm) * r1_hv(:,:,Kmm)
331      !
332      IF( .NOT.ln_dynspg_ts ) THEN        ! output the barotropic currents
333         CALL iom_put(  "ubar", uu_b(:,:,Kmm) )
334         CALL iom_put(  "vbar", vv_b(:,:,Kmm) )
335      ENDIF
336      IF( l_trddyn ) THEN                ! 3D output: asselin filter trends on momentum
337         zua(:,:,:) = ( puu(:,:,:,Kmm) - zua(:,:,:) ) * z1_2dt
338         zva(:,:,:) = ( pvv(:,:,:,Kmm) - zva(:,:,:) ) * z1_2dt
339         CALL trd_dyn( zua, zva, jpdyn_atf, kt, Kmm )
340      ENDIF
341      !
342      IF(ln_ctl)   CALL prt_ctl( tab3d_1=puu(:,:,:,Kaa), clinfo1=' nxt  - puu(:,:,:,Kaa): ', mask1=umask,   &
343         &                       tab3d_2=pvv(:,:,:,Kaa), clinfo2=' pvv(:,:,:,Kaa): '       , mask2=vmask )
344      !
345      IF( ln_dynspg_ts )   DEALLOCATE( zue, zve )
346      IF( l_trddyn     )   DEALLOCATE( zua, zva )
347      IF( ln_timing    )   CALL timing_stop('dyn_atf')
348      !
349   END SUBROUTINE dyn_atf
350
351   !!=========================================================================
352END MODULE dynatf
Note: See TracBrowser for help on using the repository browser.