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_r9838_ENHANCE04_RK3/src/OCE/DYN – NEMO

source: NEMO/branches/2018/dev_r9838_ENHANCE04_RK3/src/OCE/DYN/dynnxt.F90 @ 10023

Last change on this file since 10023 was 10023, checked in by gm, 6 years ago

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