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.
dynatf.F90 in NEMO/branches/2020/dev_r14116_HPC-04_mcastril_Mixed_Precision_implementation_final/src/OCE/DYN – NEMO

source: NEMO/branches/2020/dev_r14116_HPC-04_mcastril_Mixed_Precision_implementation_final/src/OCE/DYN/dynatf.F90 @ 14644

Last change on this file since 14644 was 14644, checked in by sparonuz, 3 years ago

Merge trunk -r14642:HEAD
  • Property svn:keywords set to Id
File size: 19.5 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-08  (A. Coward, D. Storkey) Rename dynnxt.F90 -> dynatf.F90. 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 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   USE isf_oce   , ONLY: ln_isf     ! ice shelf
44   USE isfdynatf , ONLY: isf_dynatf ! ice shelf volume filter correction subroutine
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   USE zdfdrg ,  ONLY : ln_drgice_imp, rCdU_top
53#if defined key_agrif
54   USE agrif_oce_interp
55#endif
56
57   IMPLICIT NONE
58   PRIVATE
59
60   PUBLIC    dyn_atf   ! routine called by step.F90
61
62#  include "single_precision_substitute.h90"
63#if defined key_qco   ||   defined key_linssh
64   !!----------------------------------------------------------------------
65   !!   'key_qco'                        Quasi-Eulerian vertical coordinate
66   !!       OR         EMPTY MODULE
67   !!   'key_linssh'                        Fix in time vertical coordinate
68   !!----------------------------------------------------------------------
69CONTAINS
70
71   SUBROUTINE dyn_atf( kt, Kbb, Kmm, Kaa, puu, pvv, pe3t, pe3u, pe3v )
72      INTEGER                             , INTENT(in   ) :: kt               ! ocean time-step index
73      INTEGER                             , INTENT(in   ) :: Kbb, Kmm, Kaa    ! before and after time level indices
74      REAL(dp), DIMENSION(jpi,jpj,jpk,jpt), INTENT(inout) :: puu, pvv         ! velocities to be time filtered
75      REAL(dp), DIMENSION(jpi,jpj,jpk,jpt), INTENT(inout) :: pe3t
76      REAL(wp), DIMENSION(jpi,jpj,jpk,jpt), INTENT(inout) :: pe3u, pe3v ! scale factors to be time filtered
77
78      WRITE(*,*) 'dyn_atf: You should not have seen this print! error?', kt
79   END SUBROUTINE dyn_atf
80
81#else
82
83   !! * Substitutions
84#  include "do_loop_substitute.h90"
85   !!----------------------------------------------------------------------
86   !! NEMO/OCE 4.0 , NEMO Consortium (2018)
87   !! $Id$
88   !! Software governed by the CeCILL license (see ./LICENSE)
89   !!----------------------------------------------------------------------
90CONTAINS
91
92   SUBROUTINE dyn_atf ( kt, Kbb, Kmm, Kaa, puu, pvv, pe3t, pe3u, pe3v )
93      !!----------------------------------------------------------------------
94      !!                  ***  ROUTINE dyn_atf  ***
95      !!
96      !! ** Purpose :   Finalize after horizontal velocity. Apply the boundary
97      !!             condition on the after velocity and apply the Asselin time
98      !!             filter to the now fields.
99      !!
100      !! ** Method  : * Ensure after velocities transport matches time splitting
101      !!             estimate (ln_dynspg_ts=T)
102      !!
103      !!              * Apply lateral boundary conditions on after velocity
104      !!             at the local domain boundaries through lbc_lnk call,
105      !!             at the one-way open boundaries (ln_bdy=T),
106      !!             at the AGRIF zoom   boundaries (lk_agrif=T)
107      !!
108      !!              * Apply the Asselin time filter to the now fields
109      !!             arrays to start the next time step:
110      !!                (puu(Kmm),pvv(Kmm)) = (puu(Kmm),pvv(Kmm))
111      !!                                    + rn_atfp [ (puu(Kbb),pvv(Kbb)) + (puu(Kaa),pvv(Kaa)) - 2 (puu(Kmm),pvv(Kmm)) ]
112      !!             Note that with flux form advection and non linear free surface,
113      !!             the time filter is applied on thickness weighted velocity.
114      !!             As a result, dyn_atf MUST be called after tra_atf.
115      !!
116      !! ** Action :   puu(Kmm),pvv(Kmm)   filtered now horizontal velocity
117      !!----------------------------------------------------------------------
118      INTEGER                             , INTENT(in   ) :: kt               ! ocean time-step index
119      INTEGER                             , INTENT(in   ) :: Kbb, Kmm, Kaa    ! before and after time level indices
120      REAL(dp), DIMENSION(jpi,jpj,jpk,jpt), INTENT(inout) :: puu, pvv         ! velocities to be time filtered
121      REAL(dp), DIMENSION(jpi,jpj,jpk,jpt), INTENT(inout) :: pe3t
122      REAL(wp), DIMENSION(jpi,jpj,jpk,jpt), INTENT(inout) :: pe3u, pe3v ! scale factors to be time filtered
123      !
124      INTEGER  ::   ji, jj, jk   ! dummy loop indices
125      REAL(dp)  :: zcoef
126      REAL(wp) ::   zue3a, zue3n, zue3b    ! local scalars
127      REAL(wp) ::   zve3a, zve3n, zve3b           !   -      -
128      REAL(wp), ALLOCATABLE, DIMENSION(:,:)   ::   zue, zve, zwfld
129      REAL(wp), ALLOCATABLE, DIMENSION(:,:)   ::   zutau, zvtau
130      REAL(dp), ALLOCATABLE, DIMENSION(:,:,:) ::   ze3t_f
131      REAL(dp), ALLOCATABLE, DIMENSION(:,:,:) ::   zua, zva
132      REAL(wp), ALLOCATABLE, DIMENSION(:,:,:) ::   ze3u_f, ze3v_f 
133      !!----------------------------------------------------------------------
134      !
135      IF( ln_timing    )   CALL timing_start('dyn_atf')
136      IF( ln_dynspg_ts )   ALLOCATE( zue(jpi,jpj)     , zve(jpi,jpj)     )
137      IF( l_trddyn     )   ALLOCATE( zua(jpi,jpj,jpk) , zva(jpi,jpj,jpk) )
138      !
139      IF( kt == nit000 ) THEN
140         IF(lwp) WRITE(numout,*)
141         IF(lwp) WRITE(numout,*) 'dyn_atf : Asselin time filtering'
142         IF(lwp) WRITE(numout,*) '~~~~~~~'
143      ENDIF
144
145      IF ( ln_dynspg_ts ) THEN
146         ! Ensure below that barotropic velocities match time splitting estimate
147         ! Compute actual transport and replace it with ts estimate at "after" time step
148         zue(:,:) = pe3u(:,:,1,Kaa) * puu(:,:,1,Kaa) * umask(:,:,1)
149         zve(:,:) = pe3v(:,:,1,Kaa) * pvv(:,:,1,Kaa) * vmask(:,:,1)
150         DO jk = 2, jpkm1
151            zue(:,:) = zue(:,:) + pe3u(:,:,jk,Kaa) * puu(:,:,jk,Kaa) * umask(:,:,jk)
152            zve(:,:) = zve(:,:) + pe3v(:,:,jk,Kaa) * pvv(:,:,jk,Kaa) * vmask(:,:,jk)
153         END DO
154         DO jk = 1, jpkm1
155            puu(:,:,jk,Kaa) = ( puu(:,:,jk,Kaa) - zue(:,:) * r1_hu(:,:,Kaa) + uu_b(:,:,Kaa) ) * umask(:,:,jk)
156            pvv(:,:,jk,Kaa) = ( pvv(:,:,jk,Kaa) - zve(:,:) * r1_hv(:,:,Kaa) + vv_b(:,:,Kaa) ) * vmask(:,:,jk)
157         END DO
158         !
159         IF( .NOT.ln_bt_fw ) THEN
160            ! Remove advective velocity from "now velocities"
161            ! prior to asselin filtering
162            ! In the forward case, this is done below after asselin filtering
163            ! so that asselin contribution is removed at the same time
164            DO jk = 1, jpkm1
165               puu(:,:,jk,Kmm) = ( puu(:,:,jk,Kmm) - un_adv(:,:)*r1_hu(:,:,Kmm) + uu_b(:,:,Kmm) )*umask(:,:,jk)
166               pvv(:,:,jk,Kmm) = ( pvv(:,:,jk,Kmm) - vn_adv(:,:)*r1_hv(:,:,Kmm) + vv_b(:,:,Kmm) )*vmask(:,:,jk)
167            END DO
168         ENDIF
169      ENDIF
170
171      ! Update after velocity on domain lateral boundaries
172      ! --------------------------------------------------
173# if defined key_agrif
174      CALL Agrif_dyn( kt )             !* AGRIF zoom boundaries
175# endif
176      !
177      CALL lbc_lnk( 'dynatf', puu(:,:,:,Kaa), 'U', -1.0_wp, pvv(:,:,:,Kaa), 'V', -1.0_wp )     !* local domain boundaries
178      !
179      !                                !* BDY open boundaries
180      IF( ln_bdy .AND. ln_dynspg_exp )   CALL bdy_dyn( kt, Kbb, puu, pvv, Kaa )
181      IF( ln_bdy .AND. ln_dynspg_ts  )   CALL bdy_dyn( kt, Kbb, puu, pvv, Kaa, dyn3d_only=.true. )
182
183!!$   Do we need a call to bdy_vol here??
184      !
185      IF( l_trddyn ) THEN             ! prepare the atf trend computation + some diagnostics
186         !
187         !                                  ! Kinetic energy and Conversion
188         IF( ln_KE_trd  )   CALL trd_dyn( puu(:,:,:,Kaa), pvv(:,:,:,Kaa), jpdyn_ken, kt, Kmm )
189         !
190         IF( ln_dyn_trd ) THEN              ! 3D output: total momentum trends
191            zua(:,:,:) = ( puu(:,:,:,Kaa) - puu(:,:,:,Kbb) ) * r1_Dt
192            zva(:,:,:) = ( pvv(:,:,:,Kaa) - pvv(:,:,:,Kbb) ) * r1_Dt
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(:,:,:) = puu(:,:,:,Kmm)             ! save the now velocity before the asselin filter
198         zva(:,:,:) = pvv(:,:,:,Kmm)             ! (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
205      IF( .NOT. l_1st_euler ) THEN    !* Leap-Frog : Asselin time filter
206         !                                ! =============!
207         IF( ln_linssh ) THEN             ! Fixed volume !
208            !                             ! =============!
209            DO_3D( 1, 1, 1, 1, 1, jpkm1 )
210               puu(ji,jj,jk,Kmm) = puu(ji,jj,jk,Kmm) + rn_atfp * ( puu(ji,jj,jk,Kbb) - 2._wp * puu(ji,jj,jk,Kmm) + puu(ji,jj,jk,Kaa) )
211               pvv(ji,jj,jk,Kmm) = pvv(ji,jj,jk,Kmm) + rn_atfp * ( pvv(ji,jj,jk,Kbb) - 2._wp * pvv(ji,jj,jk,Kmm) + pvv(ji,jj,jk,Kaa) )
212            END_3D
213            !                             ! ================!
214         ELSE                             ! Variable volume !
215            !                             ! ================!
216            ! Time-filtered scale factor at t-points
217            ! ----------------------------------------------------
218            ALLOCATE( ze3t_f(jpi,jpj,jpk), zwfld(jpi,jpj) )
219            DO jk = 1, jpkm1
220               ze3t_f(:,:,jk) = pe3t(:,:,jk,Kmm) + rn_atfp * ( pe3t(:,:,jk,Kbb) - 2._wp * pe3t(:,:,jk,Kmm) + pe3t(:,:,jk,Kaa) )
221            END DO
222            ! Add volume filter correction: compatibility with tracer advection scheme
223            ! => time filter + conservation correction
224            zcoef = rn_atfp * rn_Dt * r1_rho0
225            zwfld(:,:) = emp_b(:,:) - emp(:,:)
226            IF ( ln_rnf ) zwfld(:,:) =  zwfld(:,:) - ( rnf_b(:,:) - rnf(:,:) )
227
228            DO jk = 1, jpkm1
229               ze3t_f(:,:,jk) = ze3t_f(:,:,jk) - zcoef * zwfld(:,:) * tmask(:,:,jk) &
230                              &                        * pe3t(:,:,jk,Kmm) / ( ht(:,:) + 1._wp - ssmask(:,:) )
231            END DO
232            !
233            ! ice shelf melting (deal separately as it can be in depth)
234            ! PM: we could probably define a generic subroutine to do the in depth correction
235            !     to manage rnf, isf and possibly in the futur icb, tide water glacier (...)
236            !     ...(kt, coef, ktop, kbot, hz, fwf_b, fwf)
237            IF ( ln_isf ) CALL isf_dynatf( kt, Kmm, ze3t_f, CASTWP(rn_atfp * rn_Dt) )
238            !
239            pe3t(:,:,1:jpkm1,Kmm) = ze3t_f(:,:,1:jpkm1)        ! filtered scale factor at T-points
240            !
241            IF( ln_dynadv_vec ) THEN      ! Asselin filter applied on velocity
242               ! Before filtered scale factor at (u/v)-points
243               CALL dom_vvl_interpol( CASTWP(pe3t(:,:,:,Kmm)), pe3u(:,:,:,Kmm), 'U' )
244               CALL dom_vvl_interpol( CASTWP(pe3t(:,:,:,Kmm)), pe3v(:,:,:,Kmm), 'V' )
245               DO_3D( 1, 1, 1, 1, 1, jpkm1 )
246                  puu(ji,jj,jk,Kmm) = puu(ji,jj,jk,Kmm) + rn_atfp * ( puu(ji,jj,jk,Kbb) - 2._wp * puu(ji,jj,jk,Kmm) + puu(ji,jj,jk,Kaa) )
247                  pvv(ji,jj,jk,Kmm) = pvv(ji,jj,jk,Kmm) + rn_atfp * ( pvv(ji,jj,jk,Kbb) - 2._wp * pvv(ji,jj,jk,Kmm) + pvv(ji,jj,jk,Kaa) )
248               END_3D
249               !
250            ELSE                          ! Asselin filter applied on thickness weighted velocity
251               !
252               ALLOCATE( ze3u_f(jpi,jpj,jpk) , ze3v_f(jpi,jpj,jpk) )
253               ! Now filtered scale factor at (u/v)-points stored in ze3u_f, ze3v_f
254               CALL dom_vvl_interpol( CASTWP(pe3t(:,:,:,Kmm)), ze3u_f, 'U' )
255               CALL dom_vvl_interpol( CASTWP(pe3t(:,:,:,Kmm)), ze3v_f, 'V' )
256               DO_3D( 1, 1, 1, 1, 1, jpkm1 )
257                  zue3a = pe3u(ji,jj,jk,Kaa) * puu(ji,jj,jk,Kaa)
258                  zve3a = pe3v(ji,jj,jk,Kaa) * pvv(ji,jj,jk,Kaa)
259                  zue3n = pe3u(ji,jj,jk,Kmm) * puu(ji,jj,jk,Kmm)
260                  zve3n = pe3v(ji,jj,jk,Kmm) * pvv(ji,jj,jk,Kmm)
261                  zue3b = pe3u(ji,jj,jk,Kbb) * puu(ji,jj,jk,Kbb)
262                  zve3b = pe3v(ji,jj,jk,Kbb) * pvv(ji,jj,jk,Kbb)
263                  !
264                  puu(ji,jj,jk,Kmm) = ( zue3n + rn_atfp * ( zue3b - 2._wp * zue3n  + zue3a ) ) / ze3u_f(ji,jj,jk)
265                  pvv(ji,jj,jk,Kmm) = ( zve3n + rn_atfp * ( zve3b - 2._wp * zve3n  + zve3a ) ) / ze3v_f(ji,jj,jk)
266               END_3D
267               pe3u(:,:,1:jpkm1,Kmm) = ze3u_f(:,:,1:jpkm1)
268               pe3v(:,:,1:jpkm1,Kmm) = ze3v_f(:,:,1:jpkm1)
269               !
270               DEALLOCATE( ze3u_f , ze3v_f )
271            ENDIF
272            !
273            DEALLOCATE( ze3t_f, zwfld )
274         ENDIF
275         !
276         IF( ln_dynspg_ts .AND. ln_bt_fw ) THEN
277            ! Revert filtered "now" velocities to time split estimate
278            ! Doing it here also means that asselin filter contribution is removed
279            zue(:,:) = pe3u(:,:,1,Kmm) * puu(:,:,1,Kmm) * umask(:,:,1)
280            zve(:,:) = pe3v(:,:,1,Kmm) * pvv(:,:,1,Kmm) * vmask(:,:,1)
281            DO jk = 2, jpkm1
282               zue(:,:) = zue(:,:) + pe3u(:,:,jk,Kmm) * puu(:,:,jk,Kmm) * umask(:,:,jk)
283               zve(:,:) = zve(:,:) + pe3v(:,:,jk,Kmm) * pvv(:,:,jk,Kmm) * vmask(:,:,jk)
284            END DO
285            DO jk = 1, jpkm1
286               puu(:,:,jk,Kmm) = puu(:,:,jk,Kmm) - (zue(:,:) * r1_hu(:,:,Kmm) - uu_b(:,:,Kmm)) * umask(:,:,jk)
287               pvv(:,:,jk,Kmm) = pvv(:,:,jk,Kmm) - (zve(:,:) * r1_hv(:,:,Kmm) - vv_b(:,:,Kmm)) * vmask(:,:,jk)
288            END DO
289         ENDIF
290         !
291      ENDIF ! .NOT. l_1st_euler
292      !
293      ! Set "now" and "before" barotropic velocities for next time step:
294      ! JC: Would be more clever to swap variables than to make a full vertical
295      ! integration
296      !
297      IF(.NOT.ln_linssh ) THEN
298         hu(:,:,Kmm) = pe3u(:,:,1,Kmm ) * umask(:,:,1)
299         hv(:,:,Kmm) = pe3v(:,:,1,Kmm ) * vmask(:,:,1)
300         DO jk = 2, jpkm1
301            hu(:,:,Kmm) = hu(:,:,Kmm) + pe3u(:,:,jk,Kmm ) * umask(:,:,jk)
302            hv(:,:,Kmm) = hv(:,:,Kmm) + pe3v(:,:,jk,Kmm ) * vmask(:,:,jk)
303         END DO
304         r1_hu(:,:,Kmm) = ssumask(:,:) / ( hu(:,:,Kmm) + 1._wp - ssumask(:,:) )
305         r1_hv(:,:,Kmm) = ssvmask(:,:) / ( hv(:,:,Kmm) + 1._wp - ssvmask(:,:) )
306      ENDIF
307      !
308      uu_b(:,:,Kaa) = pe3u(:,:,1,Kaa) * puu(:,:,1,Kaa) * umask(:,:,1)
309      uu_b(:,:,Kmm) = pe3u(:,:,1,Kmm) * puu(:,:,1,Kmm) * umask(:,:,1)
310      vv_b(:,:,Kaa) = pe3v(:,:,1,Kaa) * pvv(:,:,1,Kaa) * vmask(:,:,1)
311      vv_b(:,:,Kmm) = pe3v(:,:,1,Kmm) * pvv(:,:,1,Kmm) * vmask(:,:,1)
312      DO jk = 2, jpkm1
313         uu_b(:,:,Kaa) = uu_b(:,:,Kaa) + pe3u(:,:,jk,Kaa) * puu(:,:,jk,Kaa) * umask(:,:,jk)
314         uu_b(:,:,Kmm) = uu_b(:,:,Kmm) + pe3u(:,:,jk,Kmm) * puu(:,:,jk,Kmm) * umask(:,:,jk)
315         vv_b(:,:,Kaa) = vv_b(:,:,Kaa) + pe3v(:,:,jk,Kaa) * pvv(:,:,jk,Kaa) * vmask(:,:,jk)
316         vv_b(:,:,Kmm) = vv_b(:,:,Kmm) + pe3v(:,:,jk,Kmm) * pvv(:,:,jk,Kmm) * vmask(:,:,jk)
317      END DO
318      uu_b(:,:,Kaa) = uu_b(:,:,Kaa) * r1_hu(:,:,Kaa)
319      vv_b(:,:,Kaa) = vv_b(:,:,Kaa) * r1_hv(:,:,Kaa)
320      uu_b(:,:,Kmm) = uu_b(:,:,Kmm) * r1_hu(:,:,Kmm)
321      vv_b(:,:,Kmm) = vv_b(:,:,Kmm) * r1_hv(:,:,Kmm)
322      !
323      IF( .NOT.ln_dynspg_ts ) THEN        ! output the barotropic currents
324         CALL iom_put(  "ubar", uu_b(:,:,Kmm) )
325         CALL iom_put(  "vbar", vv_b(:,:,Kmm) )
326      ENDIF
327      IF( l_trddyn ) THEN                ! 3D output: asselin filter trends on momentum
328         zua(:,:,:) = ( puu(:,:,:,Kmm) - zua(:,:,:) ) * r1_Dt
329         zva(:,:,:) = ( pvv(:,:,:,Kmm) - zva(:,:,:) ) * r1_Dt
330         CALL trd_dyn( zua, zva, jpdyn_atf, kt, Kmm )
331      ENDIF
332      !
333      IF ( iom_use("utau") ) THEN
334         IF ( ln_drgice_imp.OR.ln_isfcav ) THEN
335            ALLOCATE(zutau(jpi,jpj))
336            zutau(:,:) = 0._wp
337            DO_2D( 0, 0, 0, 0 )
338               jk = miku(ji,jj)
339               zutau(ji,jj) = utau(ji,jj) + 0.5_wp * rho0 * ( rCdU_top(ji+1,jj)+rCdU_top(ji,jj) ) * puu(ji,jj,jk,Kaa)
340            END_2D
341            CALL iom_put(  "utau", zutau(:,:) )
342            DEALLOCATE(zutau)
343         ELSE
344            CALL iom_put(  "utau", utau(:,:) )
345         ENDIF
346      ENDIF
347      !
348      IF ( iom_use("vtau") ) THEN
349         IF ( ln_drgice_imp.OR.ln_isfcav ) THEN
350            ALLOCATE(zvtau(jpi,jpj))
351            zvtau(:,:) = 0._wp
352            DO_2D( 0, 0, 0, 0 )
353               jk = mikv(ji,jj)
354               zvtau(ji,jj) = vtau(ji,jj) + 0.5_wp * rho0 * ( rCdU_top(ji,jj+1)+rCdU_top(ji,jj) ) * pvv(ji,jj,jk,Kaa)
355            END_2D
356            CALL iom_put(  "vtau", zvtau(:,:) )
357            DEALLOCATE(zvtau)
358         ELSE
359            CALL iom_put(  "vtau", vtau(:,:) )
360         ENDIF
361      ENDIF
362      !
363      IF(sn_cfctl%l_prtctl)   CALL prt_ctl( tab3d_1=CASTWP(puu(:,:,:,Kaa)), clinfo1=' nxt  - puu(:,:,:,Kaa): ', mask1=umask,   &
364         &                                  tab3d_2=CASTWP(pvv(:,:,:,Kaa)), clinfo2=' pvv(:,:,:,Kaa): '       , mask2=vmask )
365      !
366      IF( ln_dynspg_ts )   DEALLOCATE( zue, zve )
367      IF( l_trddyn     )   DEALLOCATE( zua, zva )
368      IF( ln_timing    )   CALL timing_stop('dyn_atf')
369      !
370   END SUBROUTINE dyn_atf
371
372#endif
373
374   !!=========================================================================
375END MODULE dynatf
Note: See TracBrowser for help on using the repository browser.