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.
dynhpg_tam.F90 in branches/TAM_V3_0/NEMOTAM/OPATAM_SRC/DYN – NEMO

source: branches/TAM_V3_0/NEMOTAM/OPATAM_SRC/DYN/dynhpg_tam.F90 @ 3400

Last change on this file since 3400 was 2587, checked in by vidard, 13 years ago

refer to ticket #798

File size: 63.6 KB
Line 
1MODULE dynhpg_tam
2#ifdef key_tam
3   !!======================================================================
4   !!                       ***  MODULE  dynhpg_tam  ***
5   !! Ocean dynamics:  hydrostatic pressure gradient trend
6   !!                  Tangent and Adjoint module
7   !!======================================================================
8   !! History of the direct module:
9   !!            1.0  !  87-09  (P. Andrich, M.-A. Foujols)  hpg_zco: Original code
10   !!            5.0  !  91-11  (G. Madec)
11   !!            7.0  !  96-01  (G. Madec)  hpg_sco: Original code for s-coordinates
12   !!            8.0  !  97-05  (G. Madec)  split dynber into dynkeg and dynhpg
13   !!            8.5  !  02-07  (G. Madec)  F90: Free form and module
14   !!            8.5  !  02-08  (A. Bozec)  hpg_zps: Original code
15   !!            9.0  !  05-10  (A. Beckmann, B.W. An)  various s-coordinate options
16   !!                           Original code for hpg_ctl, hpg_hel hpg_wdj, hpg_djc, hpg_rot
17   !!            9.0  !  05-11  (G. Madec) style & small optimisation
18   !! History of the TAM module:
19   !!            9.0  !  08-06  (A. Vidard) Skeleton
20   !!                 !  08-11  (A. Vidard) Nemo v3
21   !!----------------------------------------------------------------------
22
23   !!----------------------------------------------------------------------
24   !!   dyn_hpg      : update the momentum trend with the now horizontal
25   !!                  gradient of the hydrostatic pressure
26   !!       hpg_ctl  : initialisation and control of options
27   !!       hpg_zco  : z-coordinate scheme
28   !!       hpg_zps  : z-coordinate plus partial steps (interpolation)
29   !!       hpg_sco  : s-coordinate (standard jacobian formulation)
30   !!       hpg_hel  : s-coordinate (helsinki modification)
31   !!       hpg_wdj  : s-coordinate (weighted density jacobian)
32   !!       hpg_djc  : s-coordinate (Density Jacobian with Cubic polynomial)
33   !!       hpg_rot  : s-coordinate (ROTated axes scheme)
34   !!----------------------------------------------------------------------
35   USE par_kind,       ONLY: & ! Precision variables
36      & wp
37   USE par_oce,        ONLY: & ! Ocean space and time domain variables
38      & jpi,                 &
39      & jpj,                 & 
40      & jpk,                 &
41      & jpim1,               &
42      & jpjm1,               &
43      & jpkm1,               &
44      & jpiglo
45   USE oce_tam       , ONLY: & ! ocean dynamics and tracers
46      & ua_tl,               &
47      & va_tl,               &
48      & rhd_tl,              &
49      & ua_ad,               &
50      & va_ad,               &
51      & rhd_ad,              &
52      & gru_tl,              &
53      & grv_tl,              &
54      & gru_ad,              &
55      & grv_ad,              &   
56      & tn_tl, sn_tl,        &
57      & gtu_tl, gtv_tl,      &
58      & gsu_tl, gsv_tl,      &
59      & rhop_tl
60   USE dom_oce       , ONLY: & ! ocean space and time domain
61      & lk_vvl,              &
62      & e1u,                 &
63      & e2u,                 &
64      & e1v,                 &
65      & e2v,                 &
66#if defined key_zco
67      & e3t_0,               &
68      & e3w_0,               &
69#else
70      & e3u,                 &
71      & e3v,                 &
72      & e3w,                 &
73#endif
74      & mbathy,              &
75      & umask,               &
76      & vmask,               &
77      & mig,                 &
78      & mjg,                 &
79      & nldi,                &
80      & nldj,                &
81      & nlei,                &
82      & nlej
83   USE phycst        , ONLY: & ! physical constants
84      & grav
85   USE in_out_manager, ONLY: & ! I/O manager
86      & ctl_stop,                 &
87      & lwp,                 &
88      & numout,              & 
89      & numnam,              & 
90      & nit000,              & 
91      & nitend
92   USE gridrandom    , ONLY: & ! Random Gaussian noise on grids
93      & grid_random
94   USE dotprodfld,     ONLY: & ! Computes dot product for 3D and 2D fields
95      & dot_product
96   USE tstool_tam    , ONLY: &
97      & prntst_adj,          & !
98      & prntst_tlm,          & !
99      & stdu,                & ! stdev for u-velocity
100      & stdv,                & !           v-velocity
101      & stdr,                & !
102      & stdt,                & !
103      & stds
104
105   IMPLICIT NONE
106   PRIVATE
107
108   PUBLIC   dyn_hpg_tan    ! routine called by step_tam module
109   PUBLIC   dyn_hpg_adj    ! routine called by step_tam module
110   PUBLIC   dyn_hpg_adj_tst! routine called by test module
111#if defined key_tst_tlm
112   PUBLIC   dyn_hpg_tlm_tst! routine called by test module
113#endif
114
115   !!* Namelist nam_dynhpg : Choice of horizontal pressure gradient computation
116   LOGICAL  ::   ln_hpg_zco = .TRUE.    ! z-coordinate - full steps
117   LOGICAL  ::   ln_hpg_zps = .FALSE.   ! z-coordinate - partial steps (interpolation)
118   LOGICAL  ::   ln_hpg_sco = .FALSE.   ! s-coordinate (standard jacobian formulation)
119   LOGICAL  ::   ln_hpg_hel = .FALSE.   ! s-coordinate (helsinki modification)
120   LOGICAL  ::   ln_hpg_wdj = .FALSE.   ! s-coordinate (weighted density jacobian)
121   LOGICAL  ::   ln_hpg_djc = .FALSE.   ! s-coordinate (Density Jacobian with Cubic polynomial)
122   LOGICAL  ::   ln_hpg_rot = .FALSE.   ! s-coordinate (ROTated axes scheme)
123   REAL(wp) ::   gamm       = 0.e0      ! weighting coefficient
124
125   INTEGER  ::   nhpg  =  0             ! = 0 to 6, type of pressure gradient scheme used
126      !                                 ! (deduced from ln_hpg_... flags)
127
128   !! * Substitutions
129#  include "domzgr_substitute.h90"
130#  include "vectopt_loop_substitute.h90"
131
132CONTAINS
133
134   SUBROUTINE dyn_hpg_tan( kt )
135      !!---------------------------------------------------------------------
136      !!                  ***  ROUTINE dyn_hpg_tan  ***
137      !!
138      !! ** Method of the direct routine:
139      !!              Call the hydrostatic pressure gradient routine
140      !!              using the scheme defined in the namelist
141      !!   
142      !! ** Action : - Update (ua,va) with the now hydrastatic pressure trend
143      !!             - Save the trend (l_trddyn=T)
144      !!----------------------------------------------------------------------
145      INTEGER, INTENT(in) ::   kt   ! ocean time-step index
146      !!
147      !!----------------------------------------------------------------------
148      IF( kt == nit000 )   CALL hpg_ctl_tam       ! initialisation & control of options
149
150      SELECT CASE ( nhpg )      ! Hydrastatic pressure gradient computation
151      CASE (  0 )   ;   CALL hpg_zco_tan    ( kt )      ! z-coordinate
152      CASE (  1 )   ;   CALL hpg_zps_tan    ( kt )      ! z-coordinate plus partial steps (interpolation)
153      CASE (  2 )   ;   CALL hpg_sco_tan    ( kt )      ! s-coordinate (standard jacobian formulation)
154      CASE (  3 )   ;   CALL hpg_hel_tan    ( kt )      ! s-coordinate (helsinki modification)
155      CASE (  4 )   ;   CALL hpg_wdj_tan    ( kt )      ! s-coordinate (weighted density jacobian)
156      CASE (  5 )   ;   CALL hpg_djc_tan    ( kt )      ! s-coordinate (Density Jacobian with Cubic polynomial)
157      CASE (  6 )   ;   CALL hpg_rot_tan    ( kt )      ! s-coordinate (ROTated axes scheme)
158      END SELECT
159   END SUBROUTINE dyn_hpg_tan
160   SUBROUTINE dyn_hpg_adj( kt )
161      !!---------------------------------------------------------------------
162      !!                  ***  ROUTINE dyn_hpg_adj  ***
163      !!
164      !! ** Method of the direct routine:
165      !!              call the hydrostatic pressure gradient routine
166      !!              using the scheme defined in the namelist
167      !!   
168      !! ** Action : - Update (ua,va) with the now hydrastatic pressure trend
169      !!             - Save the trend (l_trddyn=T)
170      !!----------------------------------------------------------------------
171      INTEGER, INTENT(in) ::   kt   ! ocean time-step index
172      !!
173      !!----------------------------------------------------------------------
174      IF( kt == nitend )   CALL hpg_ctl_tam      ! initialisation & control of options
175     
176      SELECT CASE ( nhpg )      ! Hydrastatic pressure gradient computation
177      CASE (  0 )   ;   CALL hpg_zco_adj    ( kt )      ! z-coordinate
178      CASE (  1 )   ;   CALL hpg_zps_adj    ( kt )      ! z-coordinate plus partial steps (interpolation)
179      CASE (  2 )   ;   CALL hpg_sco_adj    ( kt )      ! s-coordinate (standard jacobian formulation)
180      CASE (  3 )   ;   CALL hpg_hel_adj    ( kt )      ! s-coordinate (helsinki modification)
181      CASE (  4 )   ;   CALL hpg_wdj_adj    ( kt )      ! s-coordinate (weighted density jacobian)
182      CASE (  5 )   ;   CALL hpg_djc_adj    ( kt )      ! s-coordinate (Density Jacobian with Cubic polynomial)
183      CASE (  6 )   ;   CALL hpg_rot_adj    ( kt )      ! s-coordinate (ROTated axes scheme)
184      END SELECT
185   END SUBROUTINE dyn_hpg_adj
186
187   SUBROUTINE hpg_ctl_tam
188      !!----------------------------------------------------------------------
189      !!                 ***  ROUTINE hpg_ctl_tam  ***
190      !!
191      !! ** Purpose :   initializations for the hydrostatic pressure gradient
192      !!              computation and consistency control
193      !!
194      !! ** Action  :   Read the namelist namdynhpg and check the consistency
195      !!      with the type of vertical coordinate used (zco, zps, sco)
196      !!----------------------------------------------------------------------
197      INTEGER ::   ioptio = 0      ! temporary integer
198
199      NAMELIST/nam_dynhpg/ ln_hpg_zco, ln_hpg_zps, ln_hpg_sco, ln_hpg_hel,   &
200         &                 ln_hpg_wdj, ln_hpg_djc, ln_hpg_rot, gamm
201      !!----------------------------------------------------------------------
202
203      REWIND ( numnam )               ! Read Namelist nam_dynhpg : pressure gradient calculation options
204      READ   ( numnam, nam_dynhpg )
205
206      IF(lwp) THEN                    ! Control print
207         WRITE(numout,*)
208         WRITE(numout,*) 'dyn:hpg_ctl_tam : hydrostatic pressure gradient control'
209         WRITE(numout,*) '~~~~~~~~~~~~~~~'
210         WRITE(numout,*) '       Namelist nam_dynhpg : choice of hpg scheme'
211         WRITE(numout,*) '          z-coord. - full steps                          ln_hpg_zco = ', ln_hpg_zco
212         WRITE(numout,*) '          z-coord. - partial steps (interpolation)       ln_hpg_zps = ', ln_hpg_zps
213         WRITE(numout,*) '          s-coord. (standard jacobian formulation)       ln_hpg_sco = ', ln_hpg_sco
214         WRITE(numout,*) '          s-coord. (helsinki modification)               ln_hpg_hel = ', ln_hpg_hel
215         WRITE(numout,*) '          s-coord. (weighted density jacobian)           ln_hpg_wdj = ', ln_hpg_wdj
216         WRITE(numout,*) '          s-coord. (Density Jacobian: Cubic polynomial)  ln_hpg_djc = ', ln_hpg_djc
217         WRITE(numout,*) '          s-coord. (ROTated axes scheme)                 ln_hpg_rot = ', ln_hpg_rot
218         WRITE(numout,*) '          weighting coeff. (wdj scheme)                     gamm       = ', gamm
219      ENDIF
220
221      IF( lk_vvl .AND. .NOT. ln_hpg_sco )   THEN
222         CALL ctl_stop( 'hpg_ctl_tam : variable volume key_vvl compatible only with the standard jacobian formulation hpg_sco')
223      ENDIF
224
225      !                               ! Set nhpg from ln_hpg_... flags
226      IF( ln_hpg_zco )   nhpg = 0
227      IF( ln_hpg_zps )   nhpg = 1
228      IF( ln_hpg_sco )   nhpg = 2
229      IF( ln_hpg_hel )   nhpg = 3
230      IF( ln_hpg_wdj )   nhpg = 4
231      IF( ln_hpg_djc )   nhpg = 5
232      IF( ln_hpg_rot )   nhpg = 6
233
234      !                               ! Consitency check
235      ioptio = 0 
236      IF( ln_hpg_zco )   ioptio = ioptio + 1
237      IF( ln_hpg_zps )   ioptio = ioptio + 1
238      IF( ln_hpg_sco )   ioptio = ioptio + 1
239      IF( ln_hpg_hel )   ioptio = ioptio + 1
240      IF( ln_hpg_wdj )   ioptio = ioptio + 1
241      IF( ln_hpg_djc )   ioptio = ioptio + 1
242      IF( ln_hpg_rot )   ioptio = ioptio + 1
243      IF ( ioptio /= 1 )   CALL ctl_stop( ' NO or several hydrostatic pressure gradient options used' )
244
245      !
246   END SUBROUTINE hpg_ctl_tam
247   SUBROUTINE hpg_zco_tan( kt )
248      !!---------------------------------------------------------------------
249      !!                  ***  ROUTINE hpg_zco_tan  ***
250      !!
251      !! ** Method of the direct routine:
252      !!      z-coordinate case, levels are horizontal surfaces.
253      !!      The now hydrostatic pressure gradient at a given level, jk,
254      !!      is computed by taking the vertical integral of the in-situ
255      !!      density gradient along the model level from the suface to that
256      !!      level:    zhpi = grav .....
257      !!                zhpj = grav .....
258      !!      add it to the general momentum trend (ua,va).
259      !!            ua = ua - 1/e1u * zhpi
260      !!            va = va - 1/e2v * zhpj
261      !!
262      !! ** Action : - Update (ua_tl,va_tl) with the now hydrastatic pressure trend
263      !!----------------------------------------------------------------------
264      !!
265      INTEGER, INTENT(in) ::   kt    ! ocean time-step index
266      !!
267      INTEGER  ::   ji, jj, jk       ! dummy loop indices
268      REAL(wp) ::   zcoef0, zcoef1   ! temporary scalars
269      REAL(wp), DIMENSION(jpi,jpj,jpk) :: zhpitl, zhpjtl
270      !!----------------------------------------------------------------------
271     
272      IF( kt == nit000 ) THEN
273         IF(lwp) WRITE(numout,*)
274         IF(lwp) WRITE(numout,*) 'dyn:hpg_zco_tan : hydrostatic pressure gradient trend'
275         IF(lwp) WRITE(numout,*) '~~~~~~~~~~~~~~~   z-coordinate case '
276      ENDIF
277     
278      ! Local constant initialization
279      zcoef0 = - grav * 0.5_wp
280
281      ! Surface value
282      DO jj = 2, jpjm1
283         DO ji = fs_2, fs_jpim1   ! vector opt.
284            zcoef1 = zcoef0 * fse3w(ji,jj,1)
285            ! hydrostatic pressure gradient
286            zhpitl(ji,jj,1) = zcoef1 * ( rhd_tl(ji+1,jj,1) - rhd_tl(ji,jj,1) ) / e1u(ji,jj)
287            zhpjtl(ji,jj,1) = zcoef1 * ( rhd_tl(ji,jj+1,1) - rhd_tl(ji,jj,1) ) / e2v(ji,jj)
288            ! add to the general momentum trend
289            ua_tl(ji,jj,1) = ua_tl(ji,jj,1) + zhpitl(ji,jj,1)
290            va_tl(ji,jj,1) = va_tl(ji,jj,1) + zhpjtl(ji,jj,1)
291         END DO
292      END DO
293      !
294      ! interior value (2=<jk=<jpkm1)
295      DO jk = 2, jpkm1
296         DO jj = 2, jpjm1
297            DO ji = fs_2, fs_jpim1   ! vector opt.
298               zcoef1 = zcoef0 * fse3w(ji,jj,jk)
299               ! hydrostatic pressure gradient
300               zhpitl(ji,jj,jk) = zhpitl(ji,jj,jk-1)   &
301                  &           + zcoef1 * (  ( rhd_tl(ji+1,jj,jk)+rhd_tl(ji+1,jj,jk-1) )   &
302                  &                       - ( rhd_tl(ji  ,jj,jk)+rhd_tl(ji  ,jj,jk-1) )  ) / e1u(ji,jj)
303
304               zhpjtl(ji,jj,jk) = zhpjtl(ji,jj,jk-1)   &
305                  &           + zcoef1 * (  ( rhd_tl(ji,jj+1,jk)+rhd_tl(ji,jj+1,jk-1) )   &
306                  &                       - ( rhd_tl(ji,jj,  jk)+rhd_tl(ji,jj  ,jk-1) )  ) / e2v(ji,jj)
307               ! add to the general momentum trend
308               ua_tl(ji,jj,jk) = ua_tl(ji,jj,jk) + zhpitl(ji,jj,jk)
309               va_tl(ji,jj,jk) = va_tl(ji,jj,jk) + zhpjtl(ji,jj,jk)
310            END DO
311         END DO
312      END DO
313      !
314   END SUBROUTINE hpg_zco_tan
315   SUBROUTINE hpg_zco_adj( kt )
316      !!---------------------------------------------------------------------
317      !!                  ***  ROUTINE hpg_zco_tan  ***
318      !!
319      !! ** Method of the direct routine:
320      !!      z-coordinate case, levels are horizontal surfaces.
321      !!      The now hydrostatic pressure gradient at a given level, jk,
322      !!      is computed by taking the vertical integral of the in-situ
323      !!      density gradient along the model level from the suface to that
324      !!      level:    zhpi = grav .....
325      !!                zhpj = grav .....
326      !!      add it to the general momentum trend (ua,va).
327      !!            ua = ua - 1/e1u * zhpi
328      !!            va = va - 1/e2v * zhpj
329      !!
330      !! ** Action : - Update (ua_tl,va_tl) with the now hydrastatic pressure trend
331      !!----------------------------------------------------------------------
332      !!
333      INTEGER, INTENT(in) ::   kt    ! ocean time-step index
334      !!
335      INTEGER  ::   ji, jj, jk       ! dummy loop indices
336      REAL(wp) ::   zcoef0, zcoef1   ! temporary scalars
337      REAL(wp), DIMENSION(jpi,jpj,jpk) :: zhpiad, zhpjad
338      !!----------------------------------------------------------------------
339     
340      IF( kt == nitend ) THEN
341         IF(lwp) WRITE(numout,*)
342         IF(lwp) WRITE(numout,*) 'dyn:hpg_zco_adj : hydrostatic pressure gradient trend'
343         IF(lwp) WRITE(numout,*) '~~~~~~~~~~~~~~~   z-coordinate case '
344      ENDIF
345      ! adjoint variables initialization
346      zhpiad = 0.0_wp
347      zhpjad = 0.0_wp
348      ! Local constant initialization
349      zcoef0 = - grav * 0.5
350
351      ! interior value (2=<jk=<jpkm1)
352      DO jk = jpkm1, 2, -1
353         DO jj = jpjm1, 2, -1
354            DO ji = fs_jpim1, fs_2, -1   ! vector opt.
355               zcoef1 = zcoef0 * fse3w(ji,jj,jk)
356               ! add to the general momentum trend
357               zhpiad(ji,jj,jk) = zhpiad(ji,jj,jk) + ua_ad(ji,jj,jk)
358               zhpjad(ji,jj,jk) = zhpjad(ji,jj,jk) + va_ad(ji,jj,jk)
359               ! hydrostatic pressure gradient
360               rhd_ad(ji,jj+1,jk  ) = rhd_ad(ji,jj+1,jk  ) + zhpjad(ji,jj,jk) * zcoef1 / e2v(ji,jj)
361               rhd_ad(ji,jj+1,jk-1) = rhd_ad(ji,jj+1,jk-1) + zhpjad(ji,jj,jk) * zcoef1 / e2v(ji,jj)
362               rhd_ad(ji,jj  ,jk  ) = rhd_ad(ji,jj  ,jk  ) - zhpjad(ji,jj,jk) * zcoef1 / e2v(ji,jj)
363               rhd_ad(ji,jj  ,jk-1) = rhd_ad(ji,jj  ,jk-1) - zhpjad(ji,jj,jk) * zcoef1 / e2v(ji,jj)
364               zhpjad(ji,jj  ,jk-1) = zhpjad(ji,jj  ,jk-1) + zhpjad(ji,jj,jk) 
365               zhpjad(ji,jj  ,jk  ) = 0.0_wp
366
367               rhd_ad(ji+1,jj,jk  ) = rhd_ad(ji+1,jj,jk  ) + zhpiad(ji,jj,jk) * zcoef1 / e1u(ji,jj)
368               rhd_ad(ji+1,jj,jk-1) = rhd_ad(ji+1,jj,jk-1) + zhpiad(ji,jj,jk) * zcoef1 / e1u(ji,jj)
369               rhd_ad(ji  ,jj,jk  ) = rhd_ad(ji  ,jj,jk  ) - zhpiad(ji,jj,jk) * zcoef1 / e1u(ji,jj)
370               rhd_ad(ji  ,jj,jk-1) = rhd_ad(ji  ,jj,jk-1) - zhpiad(ji,jj,jk) * zcoef1 / e1u(ji,jj)
371               zhpiad(ji  ,jj,jk-1) = zhpiad(ji  ,jj,jk-1) + zhpiad(ji,jj,jk) 
372               zhpiad(ji  ,jj,jk  ) = 0.0_wp
373
374            END DO
375         END DO
376      END DO
377      ! Surface value
378      DO jj = 2, jpjm1
379         DO ji = fs_2, fs_jpim1   ! vector opt.
380            zcoef1 = zcoef0 * fse3w(ji,jj,1)
381            ! add to the general momentum trend
382            zhpiad(ji,jj,1) = zhpiad(ji,jj,1) + ua_ad(ji,jj,1)
383            zhpjad(ji,jj,1) = zhpjad(ji,jj,1) + va_ad(ji,jj,1)
384            ! hydrostatic pressure gradient
385            rhd_ad(ji,jj+1,1) = rhd_ad(ji,jj+1,1) + zhpjad(ji,jj,1) * zcoef1 / e2v(ji,jj)
386            rhd_ad(ji,jj  ,1) = rhd_ad(ji,jj  ,1) - zhpjad(ji,jj,1) * zcoef1 / e2v(ji,jj)
387            zhpjad(ji,jj,1) = 0.0_wp
388
389            rhd_ad(ji+1,jj,1) = rhd_ad(ji+1,jj,1) + zhpiad(ji,jj,1) * zcoef1 / e1u(ji,jj)
390            rhd_ad(ji  ,jj,1) = rhd_ad(ji  ,jj,1) - zhpiad(ji,jj,1) * zcoef1 / e1u(ji,jj)
391            zhpiad(ji,jj,1) = 0.0_wp
392         END DO
393      END DO
394      !
395      !
396   END SUBROUTINE hpg_zco_adj
397   SUBROUTINE hpg_zps_tan( kt )
398      !!---------------------------------------------------------------------
399      !!                 ***  ROUTINE hpg_zps  ***
400      !!                   
401      !! ** Method of the direct routine:
402      !!              z-coordinate plus partial steps case.  blahblah...
403      !!
404      !! ** Action  : - Update (ua_tl,va_tl) with the now hydrastatic pressure trend
405      !!----------------------------------------------------------------------
406      !!
407      INTEGER, INTENT(in) ::   kt    ! ocean time-step index
408      !!
409      INTEGER  ::   ji, jj, jk                       ! dummy loop indices
410      INTEGER  ::   iku, ikv                         ! temporary integers
411      REAL(wp) ::   zcoef0, zcoef1, zcoef2, zcoef3   ! temporary scalars
412      REAL(wp), DIMENSION(jpi,jpj,jpk) :: zhpitl, zhpjtl
413      !!----------------------------------------------------------------------
414
415      IF( kt == nit000 ) THEN
416         IF(lwp) WRITE(numout,*)
417         IF(lwp) WRITE(numout,*) 'dyn:hpg_zps_tan : hydrostatic pressure gradient trend'
418         IF(lwp) WRITE(numout,*) '~~~~~~~~~~~~~~~   z-coordinate with partial steps - vector optimization'
419      ENDIF
420
421      ! Local constant initialization
422      zcoef0 = - grav * 0.5
423
424      !  Surface value
425      DO jj = 2, jpjm1
426         DO ji = fs_2, fs_jpim1   ! vector opt.
427            zcoef1 = zcoef0 * fse3w(ji,jj,1)
428            ! hydrostatic pressure gradient
429            zhpitl(ji,jj,1) = zcoef1 * ( rhd_tl(ji+1,jj  ,1) - rhd_tl(ji,jj,1) ) / e1u(ji,jj)
430            zhpjtl(ji,jj,1) = zcoef1 * ( rhd_tl(ji  ,jj+1,1) - rhd_tl(ji,jj,1) ) / e2v(ji,jj)
431            ! add to the general momentum trend
432            ua_tl(ji,jj,1) = ua_tl(ji,jj,1) + zhpitl(ji,jj,1)
433            va_tl(ji,jj,1) = va_tl(ji,jj,1) + zhpjtl(ji,jj,1)
434         END DO
435      END DO
436
437      ! interior value (2=<jk=<jpkm1)
438      DO jk = 2, jpkm1
439         DO jj = 2, jpjm1
440            DO ji = fs_2, fs_jpim1   ! vector opt.
441               zcoef1 = zcoef0 * fse3w(ji,jj,jk)
442               ! hydrostatic pressure gradient
443               zhpitl(ji,jj,jk) = zhpitl(ji,jj,jk-1)   &
444                  &           + zcoef1 * (  ( rhd_tl(ji+1,jj,jk) + rhd_tl(ji+1,jj,jk-1) )   &
445                  &                       - ( rhd_tl(ji  ,jj,jk) + rhd_tl(ji  ,jj,jk-1) )  ) / e1u(ji,jj)
446
447               zhpjtl(ji,jj,jk) = zhpjtl(ji,jj,jk-1)   &
448                  &           + zcoef1 * (  ( rhd_tl(ji,jj+1,jk) + rhd_tl(ji,jj+1,jk-1) )   &
449                  &                       - ( rhd_tl(ji,jj,  jk) + rhd_tl(ji,jj  ,jk-1) )  ) / e2v(ji,jj)
450               ! add to the general momentum trend
451               ua_tl(ji,jj,jk) = ua_tl(ji,jj,jk) + zhpitl(ji,jj,jk)
452               va_tl(ji,jj,jk) = va_tl(ji,jj,jk) + zhpjtl(ji,jj,jk)
453            END DO
454         END DO
455      END DO
456
457      ! partial steps correction at the last level  (new gradient with  intgrd.F)
458# if defined key_vectopt_loop
459         jj = 1
460         DO ji = jpi+2, jpij-jpi-1   ! vector opt. (forced unrolling)
461# else
462      DO jj = 2, jpjm1
463         DO ji = 2, jpim1
464# endif
465            iku = MIN ( mbathy(ji,jj), mbathy(ji+1,jj) ) - 1
466            ikv = MIN ( mbathy(ji,jj), mbathy(ji,jj+1) ) - 1
467            zcoef2 = zcoef0 * MIN( fse3w(ji,jj,iku), fse3w(ji+1,jj  ,iku) )
468            zcoef3 = zcoef0 * MIN( fse3w(ji,jj,ikv), fse3w(ji  ,jj+1,ikv) )
469            ! on i-direction
470            IF ( iku > 2 ) THEN
471               ! subtract old value
472               ua_tl(ji,jj,iku) = ua_tl(ji,jj,iku) - zhpitl(ji,jj,iku)
473               ! compute the new one
474               zhpitl (ji,jj,iku) = zhpitl(ji,jj,iku-1)   &
475                  + zcoef2 * ( rhd_tl(ji+1,jj,iku-1) - rhd_tl(ji,jj,iku-1) + gru_tl(ji,jj) ) / e1u(ji,jj)
476               ! add the new one to the general momentum trend
477               ua_tl(ji,jj,iku) = ua_tl(ji,jj,iku) + zhpitl(ji,jj,iku)
478            ENDIF
479            ! on j-direction
480            IF ( ikv > 2 ) THEN
481               ! subtract old value
482               va_tl(ji,jj,ikv) = va_tl(ji,jj,ikv) - zhpjtl(ji,jj,ikv)
483               ! compute the new one
484               zhpjtl (ji,jj,ikv) = zhpjtl(ji,jj,ikv-1)   &
485                  + zcoef3 * ( rhd_tl(ji,jj+1,ikv-1) - rhd_tl(ji,jj,ikv-1) + grv_tl(ji,jj) ) / e2v(ji,jj)
486               ! add the new one to the general momentum trend
487               va_tl(ji,jj,ikv) = va_tl(ji,jj,ikv) + zhpjtl(ji,jj,ikv)
488            ENDIF
489# if ! defined key_vectopt_loop
490         END DO
491# endif
492      END DO
493      !
494   END SUBROUTINE hpg_zps_tan
495   SUBROUTINE hpg_zps_adj( kt )
496      !!---------------------------------------------------------------------
497      !!                 ***  ROUTINE hpg_zps  ***
498      !!                   
499      !! ** Method of the direct routine:
500      !!              z-coordinate plus partial steps case.  blahblah...
501      !!
502      !! ** Action  : - Update (ua_tl,va_tl) with the now hydrastatic pressure trend
503      !!----------------------------------------------------------------------
504      !!
505      INTEGER, INTENT(in) ::   kt    ! ocean time-step index
506      !!
507      INTEGER  ::   ji, jj, jk                       ! dummy loop indices
508      INTEGER  ::   iku, ikv                         ! temporary integers
509      REAL(wp) ::   zcoef0, zcoef1, zcoef2, zcoef3   ! temporary scalars
510      REAL(wp), DIMENSION(jpi,jpj,jpk):: zhpiad, zhpjad
511      !!----------------------------------------------------------------------
512
513      IF( kt == nitend ) THEN
514         IF(lwp) WRITE(numout,*)
515         IF(lwp) WRITE(numout,*) 'dyn:hpg_zps_adj : hydrostatic pressure gradient trend'
516         IF(lwp) WRITE(numout,*) '~~~~~~~~~~~~~~~   z-coordinate with partial steps - vector optimization'
517      ENDIF
518      zhpiad(:,:,:) = 0.0_wp
519      zhpjad(:,:,:) = 0.0_wp
520      ! Local constant initialization
521      zcoef0 = - grav * 0.5
522
523      ! partial steps correction at the last level  (new gradient with  intgrd.F)
524# if defined key_vectopt_loop
525         jj = 1
526         DO ji = jpij-jpi-1, jpi+2, -1   ! vector opt. (forced unrolling)
527# else
528      DO jj = jpjm1, 2, -1
529         DO ji = jpim1, 2, -1
530# endif
531            iku = MIN ( mbathy(ji,jj), mbathy(ji+1,jj) ) - 1
532            ikv = MIN ( mbathy(ji,jj), mbathy(ji,jj+1) ) - 1
533            zcoef2 = zcoef0 * MIN( fse3w(ji,jj,iku), fse3w(ji+1,jj  ,iku) )
534            zcoef3 = zcoef0 * MIN( fse3w(ji,jj,ikv), fse3w(ji  ,jj+1,ikv) )
535            ! on i-direction
536            IF ( iku > 2 ) THEN
537               ! add the new one to the general momentum trend
538               zhpiad(ji,jj,iku) = zhpiad(ji,jj,iku) + ua_ad(ji,jj,iku)
539               ! compute the new one
540               rhd_ad(ji+1,jj,iku-1) = rhd_ad(ji+1,jj,iku-1) + zhpiad (ji,jj,iku) * zcoef2 / e1u(ji,jj)
541               rhd_ad(ji,jj,iku-1) = rhd_ad(ji,jj,iku-1) - zhpiad (ji,jj,iku) * zcoef2 / e1u(ji,jj)
542               gru_ad(ji,jj) = gru_ad(ji,jj) + zhpiad (ji,jj,iku) * zcoef2 / e1u(ji,jj)
543               zhpiad(ji,jj,iku-1) = zhpiad(ji,jj,iku-1) + zhpiad (ji,jj,iku)
544               zhpiad (ji,jj,iku) = 0.0_wp
545               ! subtract old value
546               zhpiad(ji,jj,iku) = zhpiad(ji,jj,iku) - ua_ad(ji,jj,iku)
547            ENDIF
548            ! on j-direction
549            IF ( ikv > 2 ) THEN
550               ! add the new one to the general momentum trend
551               zhpjad(ji,jj,ikv) = zhpjad(ji,jj,ikv) + va_ad(ji,jj,ikv)
552               ! compute the new one
553               rhd_ad(ji,jj+1,ikv-1) = rhd_ad(ji,jj+1,ikv-1) + zhpjad (ji,jj,ikv) * zcoef3 / e2v(ji,jj)
554               rhd_ad(ji,jj,ikv-1) = rhd_ad(ji,jj,ikv-1) -zhpjad (ji,jj,ikv) * zcoef3 / e2v(ji,jj)
555               grv_ad(ji,jj) = grv_ad(ji,jj) +zhpjad (ji,jj,ikv) * zcoef3 / e2v(ji,jj)
556               zhpjad(ji,jj,ikv-1) = zhpjad(ji,jj,ikv-1) + zhpjad(ji,jj,ikv)
557               zhpjad (ji,jj,ikv) = 0.0_wp
558               ! subtract old value
559               zhpjad(ji,jj,ikv) = zhpjad(ji,jj,ikv) - va_ad(ji,jj,ikv)
560            ENDIF
561# if ! defined key_vectopt_loop
562         END DO
563# endif
564      END DO
565      !
566
567
568      ! interior value (2=<jk=<jpkm1)
569      DO jk = jpkm1, 2, -1
570         DO jj = jpjm1, 2, -1
571            DO ji = fs_jpim1, fs_2, -1   ! vector opt.
572               zcoef1 = zcoef0 * fse3w(ji,jj,jk)
573               ! add to the general momentum trend
574               zhpiad(ji,jj,jk) = zhpiad(ji,jj,jk) + ua_ad(ji,jj,jk)
575               zhpjad(ji,jj,jk) = zhpjad(ji,jj,jk) + va_ad(ji,jj,jk)
576               ! hydrostatic pressure gradient
577               rhd_ad(ji,jj+1,jk  ) = rhd_ad(ji,jj+1,jk  ) + zhpjad(ji,jj,jk) * zcoef1 / e2v(ji,jj)
578               rhd_ad(ji,jj+1,jk-1) = rhd_ad(ji,jj+1,jk-1) + zhpjad(ji,jj,jk) * zcoef1 / e2v(ji,jj)
579               rhd_ad(ji,jj  ,jk  ) = rhd_ad(ji,jj  ,jk  ) - zhpjad(ji,jj,jk) * zcoef1 / e2v(ji,jj)
580               rhd_ad(ji,jj  ,jk-1) = rhd_ad(ji,jj  ,jk-1) - zhpjad(ji,jj,jk) * zcoef1 / e2v(ji,jj)
581               zhpjad(ji,jj  ,jk-1) = zhpjad(ji,jj  ,jk-1) + zhpjad(ji,jj,jk)
582               zhpjad(ji,jj  ,jk  ) = 0.0_wp
583
584               rhd_ad(ji+1,jj,jk  ) = rhd_ad(ji+1,jj,jk  ) + zhpiad(ji,jj,jk) * zcoef1 / e1u(ji,jj)
585               rhd_ad(ji+1,jj,jk-1) = rhd_ad(ji+1,jj,jk-1) + zhpiad(ji,jj,jk) * zcoef1 / e1u(ji,jj)
586               rhd_ad(ji  ,jj,jk  ) = rhd_ad(ji  ,jj,jk  ) - zhpiad(ji,jj,jk) * zcoef1 / e1u(ji,jj)
587               rhd_ad(ji  ,jj,jk-1) = rhd_ad(ji  ,jj,jk-1) - zhpiad(ji,jj,jk) * zcoef1 / e1u(ji,jj)
588               zhpiad(ji  ,jj,jk-1) = zhpiad(ji  ,jj,jk-1) + zhpiad(ji,jj,jk)
589               zhpiad(ji  ,jj,jk  ) = 0.0_wp
590            END DO
591         END DO
592      END DO
593      !  Surface value
594      DO jj = jpjm1, 2, -1
595         DO ji = fs_jpim1, fs_2, -1   ! vector opt.
596            zcoef1 = zcoef0 * fse3w(ji,jj,1)
597            ! add to the general momentum trend
598            zhpiad(ji,jj,1) = zhpiad(ji,jj,1) + ua_ad(ji,jj,1)
599            zhpjad(ji,jj,1) = zhpjad(ji,jj,1) + va_ad(ji,jj,1)
600            ! hydrostatic pressure gradient
601            rhd_ad(ji+1,jj  ,1) = rhd_ad(ji+1,jj  ,1) + zhpiad(ji,jj,1) * zcoef1 / e1u(ji,jj)
602            rhd_ad(ji  ,jj  ,1) = rhd_ad(ji  ,jj  ,1) - zhpiad(ji,jj,1) * zcoef1 / e1u(ji,jj)
603            rhd_ad(ji  ,jj+1,1) = rhd_ad(ji  ,jj+1,1) + zhpjad(ji,jj,1) * zcoef1 / e2v(ji,jj)
604            rhd_ad(ji  ,jj  ,1) = rhd_ad(ji  ,jj  ,1) - zhpjad(ji,jj,1) * zcoef1 / e2v(ji,jj)
605            zhpiad(ji  ,jj  ,1) = 0.0_wp
606            zhpjad(ji  ,jj  ,1) = 0.0_wp
607         END DO
608      END DO
609
610   END SUBROUTINE hpg_zps_adj
611   SUBROUTINE hpg_sco_tan( kt )
612      !!---------------------------------------------------------------------
613      !!                  ***  ROUTINE hpg_sco_tan  ***
614      !!
615      !! ** Method of the direct routine:   s-coordinate case. Jacobian scheme.
616      !!      The now hydrostatic pressure gradient at a given level, jk,
617      !!      is computed by taking the vertical integral of the in-situ
618      !!      density gradient along the model level from the suface to that
619      !!      level. s-coordinates (ln_sco): a corrective term is added
620      !!      to the horizontal pressure gradient :
621      !!         zhpi = grav .....  + 1/e1u mi(rhd) di[ grav dep3w ]
622      !!         zhpj = grav .....  + 1/e2v mj(rhd) dj[ grav dep3w ]
623      !!      add it to the general momentum trend (ua,va).
624      !!         ua = ua - 1/e1u * zhpi
625      !!         va = va - 1/e2v * zhpj
626      !!
627      !! ** Action : - Update (ua,va) with the now hydrastatic pressure trend
628      !!----------------------------------------------------------------------
629      !!
630      INTEGER, INTENT(in) ::   kt    ! ocean time-step index
631      CALL ctl_stop( 'hpg_sco_tan not available yet')
632   END SUBROUTINE hpg_sco_tan
633   SUBROUTINE hpg_sco_adj( kt )
634      !!---------------------------------------------------------------------
635      !!                  ***  ROUTINE hpg_sco_adj  ***
636      !!
637      !! ** Method of the direct routine:   s-coordinate case. Jacobian scheme.
638      !!      The now hydrostatic pressure gradient at a given level, jk,
639      !!      is computed by taking the vertical integral of the in-situ
640      !!      density gradient along the model level from the suface to that
641      !!      level. s-coordinates (ln_sco): a corrective term is added
642      !!      to the horizontal pressure gradient :
643      !!         zhpi = grav .....  + 1/e1u mi(rhd) di[ grav dep3w ]
644      !!         zhpj = grav .....  + 1/e2v mj(rhd) dj[ grav dep3w ]
645      !!      add it to the general momentum trend (ua,va).
646      !!         ua = ua - 1/e1u * zhpi
647      !!         va = va - 1/e2v * zhpj
648      !!
649      !! ** Action : - Update (ua,va) with the now hydrastatic pressure trend
650      !!----------------------------------------------------------------------
651      !!
652      INTEGER, INTENT(in) ::   kt    ! ocean time-step index
653      CALL ctl_stop( 'hpg_sco_adj not available yet')
654   END SUBROUTINE hpg_sco_adj
655   SUBROUTINE hpg_hel_tan( kt )
656      !!---------------------------------------------------------------------
657      !!                  ***  ROUTINE hpg_hel_tan  ***
658      !!
659      !! ** Method of the direct routine:   s-coordinate case.
660      !!      The now hydrostatic pressure gradient at a given level
661      !!      jk is computed by taking the vertical integral of the in-situ
662      !!      density gradient along the model level from the suface to that
663      !!      level. s-coordinates (ln_sco): a corrective term is added
664      !!      to the horizontal pressure gradient :
665      !!         zhpi = grav .....  + 1/e1u mi(rhd) di[ grav dep3w ]
666      !!         zhpj = grav .....  + 1/e2v mj(rhd) dj[ grav dep3w ]
667      !!      add it to the general momentum trend (ua,va).
668      !!         ua = ua - 1/e1u * zhpi
669      !!         va = va - 1/e2v * zhpj
670      !!
671      !! ** Action : - Update (ua,va) with the now hydrastatic pressure trend
672      !!             - Save the trend (l_trddyn=T)
673      !!----------------------------------------------------------------------
674      !!
675      INTEGER, INTENT(in) ::   kt    ! ocean time-step index
676      CALL ctl_stop( 'hpg_hel_tan not available yet')
677   END SUBROUTINE hpg_hel_tan
678   SUBROUTINE hpg_hel_adj( kt )
679      !!---------------------------------------------------------------------
680      !!                  ***  ROUTINE hpg_hel_adj  ***
681      !!
682      !! ** Method of the direct routine:   s-coordinate case.
683      !!      The now hydrostatic pressure gradient at a given level
684      !!      jk is computed by taking the vertical integral of the in-situ
685      !!      density gradient along the model level from the suface to that
686      !!      level. s-coordinates (ln_sco): a corrective term is added
687      !!      to the horizontal pressure gradient :
688      !!         zhpi = grav .....  + 1/e1u mi(rhd) di[ grav dep3w ]
689      !!         zhpj = grav .....  + 1/e2v mj(rhd) dj[ grav dep3w ]
690      !!      add it to the general momentum trend (ua,va).
691      !!         ua = ua - 1/e1u * zhpi
692      !!         va = va - 1/e2v * zhpj
693      !!
694      !! ** Action : - Update (ua,va) with the now hydrastatic pressure trend
695      !!             - Save the trend (l_trddyn=T)
696      !!----------------------------------------------------------------------
697      !!
698      INTEGER, INTENT(in) ::   kt    ! ocean time-step index
699      CALL ctl_stop( 'hpg_hel_adj not available yet')
700   END SUBROUTINE hpg_hel_adj
701   SUBROUTINE hpg_wdj_tan( kt )
702      !!---------------------------------------------------------------------
703      !!                  ***  ROUTINE hpg_wdj_tan  ***
704      !!
705      !! ** Method of the direct roiutine:
706      !!      Weighted Density Jacobian (wdj) scheme (song 1998)
707      !!      The weighting coefficients from the namelist parameter gamm
708      !!      (alpha=0.5-gamm ; beta=1-alpha=0.5+gamm)
709      !!
710      !! Reference : Song, Mon. Wea. Rev., 126, 3213-3230, 1998.
711      !!----------------------------------------------------------------------
712      !!
713      INTEGER, INTENT(in) ::   kt    ! ocean time-step index
714      CALL ctl_stop( 'hpg_wdj_tan not available yet')
715   END SUBROUTINE hpg_wdj_tan
716   SUBROUTINE hpg_wdj_adj( kt )
717      !!---------------------------------------------------------------------
718      !!                  ***  ROUTINE hpg_wdj_adj  ***
719      !!
720      !! ** Method of the direct roiutine:
721      !!      Weighted Density Jacobian (wdj) scheme (song 1998)
722      !!      The weighting coefficients from the namelist parameter gamm
723      !!      (alpha=0.5-gamm ; beta=1-alpha=0.5+gamm)
724      !!
725      !! Reference : Song, Mon. Wea. Rev., 126, 3213-3230, 1998.
726      !!----------------------------------------------------------------------
727      !!
728      INTEGER, INTENT(in) ::   kt    ! ocean time-step index
729      CALL ctl_stop( 'hpg_wdj_adj not available yet')
730   END SUBROUTINE hpg_wdj_adj
731   SUBROUTINE hpg_djc_tan( kt )
732      !!---------------------------------------------------------------------
733      !!                  ***  ROUTINE hpg_djc_tan  ***
734      !!
735      !! ** Method  :   Density Jacobian with Cubic polynomial scheme
736      !!
737      !! Reference: Shchepetkin and McWilliams, J. Geophys. Res., 108(C3), 3090, 2003
738      !!----------------------------------------------------------------------
739      !!
740      INTEGER, INTENT(in) ::   kt    ! ocean time-step index
741      !!
742      CALL ctl_stop( 'hpg_djc_tan not available yet')
743   END SUBROUTINE hpg_djc_tan
744   SUBROUTINE hpg_djc_adj( kt )
745      !!---------------------------------------------------------------------
746      !!                  ***  ROUTINE hpg_djc_adj  ***
747      !!
748      !! ** Method  :   Density Jacobian with Cubic polynomial scheme
749      !!
750      !! Reference: Shchepetkin and McWilliams, J. Geophys. Res., 108(C3), 3090, 2003
751      !!----------------------------------------------------------------------
752      !!
753      INTEGER, INTENT(in) ::   kt    ! ocean time-step index
754      !!
755      CALL ctl_stop( 'hpg_djc_adj not available yet')
756   END SUBROUTINE hpg_djc_adj
757   SUBROUTINE hpg_rot_tan( kt )
758      !!---------------------------------------------------------------------
759      !!                  ***  ROUTINE hpg_rot_tan  ***
760      !!
761      !! ** Method  :   rotated axes scheme (Thiem and Berntsen 2005)
762      !!
763      !! Reference: Thiem & Berntsen, Ocean Modelling, In press, 2005.
764      !!----------------------------------------------------------------------
765      !!
766      INTEGER, INTENT(in) ::   kt    ! ocean time-step index
767            !!
768      CALL ctl_stop( 'hpg_rot_tan not available yet')
769   END SUBROUTINE hpg_rot_tan
770   SUBROUTINE hpg_rot_adj( kt )
771      !!---------------------------------------------------------------------
772      !!                  ***  ROUTINE hpg_rot_adj  ***
773      !!
774      !! ** Method  :   rotated axes scheme (Thiem and Berntsen 2005)
775      !!
776      !! Reference: Thiem & Berntsen, Ocean Modelling, In press, 2005.
777      !!----------------------------------------------------------------------
778      !!
779      INTEGER, INTENT(in) ::   kt    ! ocean time-step index
780            !!
781      CALL ctl_stop( 'hpg_rot_adj not available yet')
782   END SUBROUTINE hpg_rot_adj
783
784   SUBROUTINE dyn_hpg_adj_tst( kumadt )
785      !!-----------------------------------------------------------------------
786      !!
787      !!                  ***  ROUTINE dynhpg_adj_tst ***
788      !!
789      !! ** Purpose : Test the adjoint routine.
790      !!
791      !! ** Method  : Verify the scalar product
792      !!           
793      !!                 ( L dx )^T W dy  =  dx^T L^T W dy
794      !!
795      !!              where  L   = tangent routine
796      !!                     L^T = adjoint routine
797      !!                     W   = diagonal matrix of scale factors
798      !!                     dx  = input perturbation (random field)
799      !!                     dy  = L dx
800      !!
801      !! ** Action  : Separate tests are applied for the following dx and dy:
802      !!               
803      !!              1) dx = ( SSH ) and dy = ( SSH )
804      !!                   
805      !! History :
806      !!        ! 08-07 (A. Vidard)
807      !!-----------------------------------------------------------------------
808      !! * Modules used
809
810      !! * Arguments
811      INTEGER, INTENT(IN) :: &
812         & kumadt             ! Output unit
813
814      REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::   &
815         & zrhd_tlin,              &  ! in situ density anomalie
816         & zua_tlin,               &  ! after u- velocity
817         & zva_tlin,               &  ! after v- velocity
818         & zua_tlout,              &  ! after u- velocity
819         & zva_tlout                  ! after v- velocity
820      REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::   &
821         & zrhd_adout,             &  ! in situ density anomalie
822         & zua_adout,              &  ! after u- velocity
823         & zva_adout,              &  ! after v- velocity
824         & zua_adin,               &  ! after u- velocity
825         & zva_adin                   ! after v- velocity
826      REAL(wp), DIMENSION(:,:), ALLOCATABLE ::   &
827         & zgru_tlin,              &
828         & zgrv_tlin,              &
829         & zgru_adout,             &
830         & zgrv_adout
831         
832      REAL(KIND=wp), DIMENSION(:,:,:), ALLOCATABLE :: &
833         & zrh,          & ! 3D random field for rhd
834         & zau,          & ! 3D random field for u
835         & zav             ! 3D random field for v
836      REAL(wp), DIMENSION(:,:), ALLOCATABLE ::   &
837         & zgru,         & ! 2D random field for gru
838         & zgrv            ! 2D random field for grv
839      REAL(KIND=wp) ::   &
840         & zsp1,         & ! scalar product involving the tangent routine
841         & zsp1_1,       & !   scalar product components
842         & zsp1_2,       & 
843         & zsp2,         & ! scalar product involving the adjoint routine
844         & zsp2_1,       & !   scalar product components
845         & zsp2_2,       & 
846         & zsp2_3,       & 
847         & zsp2_4,       & 
848         & zsp2_5
849      INTEGER, DIMENSION(jpi,jpj) :: &
850         & iseed_2d           ! 2D seed for the random number generator
851      INTEGER :: &
852         & iseed, &
853         & ji, &
854         & jj, &
855         & jk
856      CHARACTER(LEN=14) :: cl_name
857
858      ! Allocate memory
859      ALLOCATE( & 
860         & zrhd_tlin(jpi,jpj,jpk),  &
861         & zua_tlin(jpi,jpj,jpk),   &
862         & zva_tlin(jpi,jpj,jpk),   &
863         & zgru_tlin(jpi,jpj),      & 
864         & zgrv_tlin(jpi,jpj),      & 
865         & zua_tlout(jpi,jpj,jpk),  &
866         & zva_tlout(jpi,jpj,jpk),  &
867         & zrhd_adout(jpi,jpj,jpk), &
868         & zua_adout(jpi,jpj,jpk),  &
869         & zva_adout(jpi,jpj,jpk),  &
870         & zgru_adout(jpi,jpj),     & 
871         & zgrv_adout(jpi,jpj),     & 
872         & zua_adin(jpi,jpj,jpk),   &
873         & zva_adin(jpi,jpj,jpk),   &
874         & zrh(jpi,jpj,jpk),        & 
875         & zau(jpi,jpj,jpk),        & 
876         & zav(jpi,jpj,jpk),        & 
877         & zgru(jpi,jpj),           &
878         & zgrv(jpi,jpj)            &
879         &     )
880 
881
882      !==================================================================
883      ! 1) dx = ( un_tl, vn_tl, hdivn_tl ) and
884      !    dy = ( hdivb_tl, hdivn_tl )
885      !==================================================================
886
887      !--------------------------------------------------------------------
888      ! Reset the tangent and adjoint variables
889      !--------------------------------------------------------------------
890      zrhd_tlin(:,:,:)  = 0.0_wp 
891      zua_tlin(:,:,:)   = 0.0_wp   
892      zva_tlin(:,:,:)   = 0.0_wp   
893      zgru_tlin(:,:)    = 0.0_wp
894      zgrv_tlin(:,:)    = 0.0_wp
895      zua_tlout(:,:,:)  = 0.0_wp 
896      zva_tlout(:,:,:)  = 0.0_wp 
897      zgru_adout(:,:)   = 0.0_wp
898      zgrv_adout(:,:)   = 0.0_wp
899      zrhd_adout(:,:,:) = 0.0_wp 
900      zua_adout(:,:,:)  = 0.0_wp 
901      zva_adout(:,:,:)  = 0.0_wp 
902      zua_adin(:,:,:)   = 0.0_wp   
903      zva_adin(:,:,:)   = 0.0_wp   
904      zrh(:,:,:)        = 0.0_wp         
905      zau(:,:,:)        = 0.0_wp         
906      zav(:,:,:)        = 0.0_wp 
907      zgru(:,:)         = 0.0_wp
908      zgrv(:,:)         = 0.0_wp
909
910
911      gru_tl(:,:)   = 0.0_wp
912      grv_tl(:,:)   = 0.0_wp
913      gru_ad(:,:)   = 0.0_wp
914      grv_ad(:,:)   = 0.0_wp
915      ua_tl(:,:,:)  = 0.0_wp
916      va_tl(:,:,:)  = 0.0_wp
917      rhd_tl(:,:,:) = 0.0_wp
918      ua_ad(:,:,:)  = 0.0_wp
919      va_ad(:,:,:)  = 0.0_wp
920      rhd_ad(:,:,:) = 0.0_wp
921
922      !--------------------------------------------------------------------
923      ! Initialize the tangent input with random noise: dx
924      !--------------------------------------------------------------------
925
926      DO jj = 1, jpj
927         DO ji = 1, jpi
928            iseed_2d(ji,jj) = - ( 596035 + &
929               &                  mig(ji) + ( mjg(jj) - 1 ) * jpiglo )
930         END DO
931      END DO
932      CALL grid_random( iseed_2d, zau, 'U', 0.0_wp, stdu )
933
934      DO jj = 1, jpj
935         DO ji = 1, jpi
936            iseed_2d(ji,jj) = - ( 523432 + &
937               &                  mig(ji) + ( mjg(jj) - 1 ) * jpiglo )
938         END DO
939      END DO
940      CALL grid_random( iseed_2d, zav, 'V', 0.0_wp, stdv )
941
942      DO jj = 1, jpj
943         DO ji = 1, jpi
944            iseed_2d(ji,jj) = - ( 456953 + &
945               &                  mig(ji) + ( mjg(jj) - 1 ) * jpiglo )
946         END DO
947      END DO
948      CALL grid_random( iseed_2d, zrh, 'W', 0.0_wp, stdr )
949
950      DO jj = 1, jpj
951         DO ji = 1, jpi
952            iseed_2d(ji,jj) = - ( 432545 + &
953               &                  mig(ji) + ( mjg(jj) - 1 ) * jpiglo )
954         END DO
955      END DO
956      CALL grid_random( iseed_2d, zgru, 'U', 0.0_wp, stdu )
957
958      DO jj = 1, jpj
959         DO ji = 1, jpi
960            iseed_2d(ji,jj) = - ( 287503 + &
961               &                  mig(ji) + ( mjg(jj) - 1 ) * jpiglo )
962         END DO
963      END DO
964      CALL grid_random( iseed_2d, zgrv, 'V', 0.0_wp, stdv )
965
966      DO jk = 1, jpk
967         DO jj = nldj, nlej
968            DO ji = nldi, nlei
969               zrhd_tlin(ji,jj,jk) = zrh(ji,jj,jk)
970               zua_tlin(ji,jj,jk)  = zau(ji,jj,jk)
971               zva_tlin(ji,jj,jk)  = zav(ji,jj,jk)
972            END DO
973         END DO
974      END DO
975      DO jj = nldj, nlej
976         DO ji = nldi, nlei
977            zgru_tlin(ji,jj)   = zgru(ji,jj)
978            zgrv_tlin(ji,jj)   = zgrv(ji,jj)
979         END DO
980      END DO
981      ua_tl(:,:,:)  = zua_tlin(:,:,:)
982      va_tl(:,:,:)  = zva_tlin(:,:,:)
983      rhd_tl(:,:,:) = zrhd_tlin(:,:,:)
984      gru_tl(:,:)   = zgru_tlin(:,:)
985      grv_tl(:,:)   = zgrv_tlin(:,:) 
986
987      CALL dyn_hpg_tan ( nit000 )
988
989      zua_tlout(:,:,:) = ua_tl(:,:,:)
990      zva_tlout(:,:,:) = va_tl(:,:,:)
991      !--------------------------------------------------------------------
992      ! Initialize the adjoint variables: dy^* = W dy
993      !--------------------------------------------------------------------
994
995      DO jk = 1, jpk
996        DO jj = nldj, nlej
997           DO ji = nldi, nlei
998              zua_adin(ji,jj,jk) = zua_tlout(ji,jj,jk) &
999                 &               * e1u(ji,jj) * e2u(ji,jj) * fse3u(ji,jj,jk) &
1000                 &               * umask(ji,jj,jk)
1001              zva_adin(ji,jj,jk) = zva_tlout(ji,jj,jk) &
1002                 &               * e1v(ji,jj) * e2v(ji,jj) * fse3v(ji,jj,jk) &
1003                 &               * vmask(ji,jj,jk)
1004            END DO
1005         END DO
1006      END DO
1007      !--------------------------------------------------------------------
1008      ! Compute the scalar product: ( L dx )^T W dy
1009      !--------------------------------------------------------------------
1010
1011      zsp1_1 = DOT_PRODUCT( zua_tlout, zua_adin )
1012      zsp1_2 = DOT_PRODUCT( zva_tlout, zva_adin )
1013      zsp1   = zsp1_1 + zsp1_2
1014
1015      !--------------------------------------------------------------------
1016      ! Call the adjoint routine: dx^* = L^T dy^*
1017      !--------------------------------------------------------------------
1018
1019      ua_ad(:,:,:) = zua_adin(:,:,:)
1020      va_ad(:,:,:) = zva_adin(:,:,:)
1021
1022      CALL dyn_hpg_adj ( nit000 )
1023
1024      zgru_adout(:,:)   = gru_ad(:,:)
1025      zgrv_adout(:,:)   = grv_ad(:,:)
1026      zrhd_adout(:,:,:) = rhd_ad(:,:,:)
1027      zua_adout(:,:,:)  = ua_ad(:,:,:)
1028      zva_adout(:,:,:)  = va_ad(:,:,:)
1029
1030      zsp2_1 = DOT_PRODUCT( zgru_tlin, zgru_adout )
1031      zsp2_2 = DOT_PRODUCT( zgrv_tlin, zgrv_adout )
1032      zsp2_3 = DOT_PRODUCT( zrhd_tlin, zrhd_adout )
1033      zsp2_4 = DOT_PRODUCT( zua_tlin, zua_adout )
1034      zsp2_5 = DOT_PRODUCT( zva_tlin, zva_adout )
1035      zsp2   = zsp2_1 + zsp2_2 + zsp2_3 + zsp2_4 + zsp2_5
1036      ! Compare the scalar products
1037
1038      cl_name = 'dyn_hpg_adj   '
1039      CALL prntst_adj( cl_name, kumadt, zsp1, zsp2 )
1040
1041      DEALLOCATE( &
1042         & zrhd_tlin,  &
1043         & zua_tlin,   &
1044         & zva_tlin,   &
1045         & zgru_tlin,  & 
1046         & zgrv_tlin,  & 
1047         & zua_tlout,  &
1048         & zva_tlout,  &
1049         & zrhd_adout, &
1050         & zua_adout,  &
1051         & zva_adout,  &
1052         & zgru_adout, & 
1053         & zgrv_adout, & 
1054         & zua_adin,   &
1055         & zva_adin,   &
1056         & zrh,        & 
1057         & zau,        & 
1058         & zav,        & 
1059         & zgru,       &
1060         & zgrv        &
1061         &              )
1062   END SUBROUTINE dyn_hpg_adj_tst
1063#if defined key_tst_tlm
1064   SUBROUTINE dyn_hpg_tlm_tst( kumadt )
1065      !!-----------------------------------------------------------------------
1066      !!
1067      !!                  ***  ROUTINE dyn_hpg_tlm_tst ***
1068      !!
1069      !! ** Purpose : Test the adjoint routine.
1070      !!
1071      !! ** Method  : Verify the tangent with Taylor expansion
1072      !!           
1073      !!                 M(x+hdx) = M(x) + L(hdx) + O(h^2)
1074      !!
1075      !!              where  L   = tangent routine
1076      !!                     M   = direct routine
1077      !!                     dx  = input perturbation (random field)
1078      !!                     h   = ration on perturbation
1079      !!                   
1080      !! History :
1081      !!        ! 09-08 (A. Vigilant)
1082      !!-----------------------------------------------------------------------
1083      !! * Modules used
1084      USE dynhpg
1085      USE zpshde
1086      USE eosbn2,     ONLY: & ! horizontal & vertical advective trend
1087        & eos
1088      USE zpshde_tam
1089      USE eosbn2_tam,     ONLY: & ! horizontal & vertical advective trend
1090        & eos_tan
1091      USE tamtrj              ! writing out state trajectory
1092      USE par_tlm,    ONLY: &
1093        & tlm_bch,          &
1094        & cur_loop,         &
1095        & h_ratio
1096      USE istate_mod
1097      USE divcur             ! horizontal divergence and relative vorticity
1098      USE wzvmod             !  vertical velocity
1099      USE gridrandom, ONLY: &
1100        & grid_rd_sd
1101      USE trj_tam
1102      USE oce       , ONLY: & ! ocean dynamics and tracers variables
1103        & ua, va, rhd,      &
1104        & gru, grv,         &
1105        & un, vn,           &     
1106        & tn, sn, gtu, gtv, &
1107        & gsu, gsv, rhop
1108      USE opatam_tst_ini, ONLY: &
1109       & tlm_namrd
1110      USE tamctl,         ONLY: & ! Control parameters
1111       & numtan, numtan_sc
1112      !! * Arguments
1113      INTEGER, INTENT(IN) :: &
1114         & kumadt             ! Output unit
1115      !! * Local declarations
1116      REAL(wp), DIMENSION(:,:,:), ALLOCATABLE ::   &
1117         & zrd_tlin,               &  ! in situ density anomalie
1118         & zua_tlin,               &  ! after u- velocity
1119         & zva_tlin,               &  ! after v- velocity
1120         & ztn_tlin,               &  ! after u- velocity
1121         & zsn_tlin,               &  ! after v- velocity
1122         & zua_wop,                &  ! after u- velocity
1123         & zva_wop,                &  ! after v- velocity
1124         & zua_out,                &  ! after u- velocity
1125         & zva_out                    ! after v- velocity
1126
1127      REAL(wp), DIMENSION(:,:), ALLOCATABLE ::   &
1128         & zgru_tlin,              &
1129         & zgrv_tlin
1130
1131      REAL(KIND=wp), DIMENSION(:,:,:), ALLOCATABLE :: &
1132         & zrh,          & ! 3D random field for rhd
1133         & zau,          & ! 3D random field for u
1134         & zav             ! 3D random field for v
1135      REAL(wp), DIMENSION(:,:), ALLOCATABLE ::   &
1136         & zgru,         & ! 2D random field for gru
1137         & zgrv            ! 2D random field for grv
1138
1139      REAL(KIND=wp) ::   &
1140         & zsp1,         & ! scalar product
1141         & zsp1_1,       & ! scalar product
1142         & zsp1_2,       & 
1143         & zsp2,         & ! scalar product
1144         & zsp2_1,       & ! scalar product
1145         & zsp2_2,       &
1146         & zsp3,         & ! scalar product
1147         & zsp3_1,       & 
1148         & zsp3_2,       & 
1149         & zzsp,         & ! scalar product
1150         & zzsp_1,       & 
1151         & zzsp_2,       &
1152         & gamma,            &
1153         & zgsp1,            &
1154         & zgsp2,            &
1155         & zgsp3,            &
1156         & zgsp4,            &
1157         & zgsp5,            &
1158         & zgsp6,            &
1159         & zgsp7 
1160      INTEGER :: &
1161         & ji, &
1162         & jj, &
1163         & jk
1164      CHARACTER(LEN=14)   :: cl_name
1165      CHARACTER (LEN=128) :: file_out, file_wop, file_xdx
1166      CHARACTER (LEN=90)  ::  FMT
1167      REAL(KIND=wp), DIMENSION(100):: &
1168         & zscua, zscva,    &
1169         & zscerrua,        &
1170         & zscerrva
1171      INTEGER, DIMENSION(100):: &
1172         & iiposua, iiposva,    &
1173         & ijposua, ijposva,    & 
1174         & ikposua, ikposva
1175      INTEGER::             &
1176         & ii,              &
1177         & isamp=40,        &
1178         & jsamp=40,        &
1179         & ksamp=10,        &
1180         & numsctlm
1181     REAL(KIND=wp), DIMENSION(jpi,jpj,jpk) :: &
1182         & zerrua, zerrva
1183      ! Allocate memory
1184      ALLOCATE( & 
1185         & zrd_tlin(jpi,jpj,jpk),   &
1186         & zua_tlin(jpi,jpj,jpk),   &
1187         & zva_tlin(jpi,jpj,jpk),   &
1188         & ztn_tlin(jpi,jpj,jpk),   &
1189         & zsn_tlin(jpi,jpj,jpk),   &
1190         & zgru_tlin(jpi,jpj),      & 
1191         & zgrv_tlin(jpi,jpj),      & 
1192         & zua_wop  (jpi,jpj,jpk),  &
1193         & zva_wop  (jpi,jpj,jpk),  &
1194         & zua_out  (jpi,jpj,jpk),  &
1195         & zva_out  (jpi,jpj,jpk),  &
1196         & zrh(      jpi,jpj,jpk),  & 
1197         & zau(      jpi,jpj,jpk),  & 
1198         & zav(      jpi,jpj,jpk),  & 
1199         & zgru(     jpi,jpj),      &
1200         & zgrv(     jpi,jpj)       &
1201         &     )
1202
1203      !--------------------------------------------------------------------
1204      ! Reset variables
1205      !--------------------------------------------------------------------
1206      zrd_tlin( :,:,:) = 0.0_wp
1207      zgru_tlin(  :,:) = 0.0_wp
1208      zgrv_tlin(  :,:) = 0.0_wp
1209      zua_tlin( :,:,:) = 0.0_wp
1210      zva_tlin( :,:,:) = 0.0_wp
1211      ztn_tlin( :,:,:) = 0.0_wp
1212      zsn_tlin( :,:,:) = 0.0_wp
1213      zua_out ( :,:,:) = 0.0_wp
1214      zva_out ( :,:,:) = 0.0_wp
1215      zua_wop ( :,:,:) = 0.0_wp
1216      zva_wop ( :,:,:) = 0.0_wp
1217
1218      zrh(:,:,:)        = 0.0_wp         
1219      zau(:,:,:)        = 0.0_wp         
1220      zav(:,:,:)        = 0.0_wp 
1221      zgru(:,:)         = 0.0_wp
1222      zgrv(:,:)         = 0.0_wp
1223
1224      zscua(:)         = 0.0_wp
1225      zscva(:)         = 0.0_wp
1226      zscerrua(:)      = 0.0_wp
1227      zscerrva(:)      = 0.0_wp
1228      zerrua(:,:,:)    = 0.0_wp
1229      zerrva(:,:,:)    = 0.0_wp
1230      !--------------------------------------------------------------------
1231      ! Output filename Xn=F(X0)
1232      !--------------------------------------------------------------------
1233      CALL tlm_namrd
1234      gamma = h_ratio 
1235      file_wop='trj_wop_dynhpg'
1236      file_xdx='trj_xdx_dynhpg'
1237       !--------------------------------------------------------------------
1238      ! Initialize the tangent input with random noise: dx
1239      !--------------------------------------------------------------------
1240      IF (( cur_loop .NE. 0) .OR. ( gamma .NE. 0.0_wp) )THEN
1241         CALL grid_rd_sd( 596035, zau,  'U', 0.0_wp, stdu)
1242         CALL grid_rd_sd( 523432, zav,  'V', 0.0_wp, stdv)
1243         CALL grid_rd_sd( 456953, zrh,  'W', 0.0_wp, stdr)
1244         CALL grid_rd_sd( 432545, zgru, 'U', 0.0_wp, stdu)
1245         CALL grid_rd_sd( 287503, zgrv, 'V', 0.0_wp, stdv) 
1246         DO jk = 1, jpk
1247            DO jj = nldj, nlej
1248               DO ji = nldi, nlei
1249                  zrd_tlin(ji,jj,jk) = zrh(ji,jj,jk)
1250                  zua_tlin(ji,jj,jk)  = zau(ji,jj,jk)
1251                  zva_tlin(ji,jj,jk)  = zav(ji,jj,jk)
1252               END DO
1253            END DO
1254         END DO
1255
1256         DO jj = nldj, nlej
1257            DO ji = nldi, nlei
1258               zgru_tlin(ji,jj)   = zgru(ji,jj)
1259               zgrv_tlin(ji,jj)   = zgrv(ji,jj)
1260            END DO
1261         END DO
1262      ENDIF
1263      !--------------------------------------------------------------------
1264      ! Complete Init for Direct
1265      !-------------------------------------------------------------------
1266      IF ( tlm_bch /= 2 )      CALL istate_p 
1267
1268      ! *** initialize the reference trajectory
1269      ! ------------
1270      CALL  trj_rea( nit000-1, 1 )
1271!      CALL  trj_rea( nit000, 1 )
1272      ua(:,:,:)       = un(:,:,:)
1273      va(:,:,:)       = vn(:,:,:) 
1274
1275      !  Compute rhd, gru and grv
1276      CALL eos(tn, sn, rhd, rhop)
1277      CALL zps_hde(nit000, tn, sn, rhd, gtu, gsu, gru, gtv, gsv, grv)
1278
1279
1280      IF (( cur_loop .NE. 0) .OR. ( gamma .NE. 0.0_wp) )THEN
1281
1282         zrd_tlin(:,:,:) = gamma * zrd_tlin(:,:,:)
1283         rhd(:,:,:)       = rhd(:,:,:) + zrd_tlin(:,:,:)
1284
1285         zua_tlin(:,:,:) = gamma * zua_tlin(:,:,:)
1286         ua(:,:,:)       = ua(:,:,:) + zua_tlin(:,:,:)
1287
1288         zva_tlin(:,:,:) = gamma * zva_tlin(:,:,:)
1289         va(:,:,:)       = va(:,:,:) + zva_tlin(:,:,:)
1290
1291         zgru_tlin(:,:) = gamma * zgru_tlin(:,:)
1292         gru(:,:)       = gru(:,:) + zgru_tlin(:,:)
1293
1294         zgrv_tlin(:,:) = gamma * zgrv_tlin(:,:)
1295         grv(:,:)       = grv(:,:) + zgrv_tlin(:,:)
1296      ENDIF 
1297      !--------------------------------------------------------------------
1298      !  Compute the direct model F(X0,t=n) = Xn
1299      !--------------------------------------------------------------------
1300      IF ( tlm_bch /= 2 ) CALL dyn_hpg(nit000)
1301      IF ( tlm_bch == 0 ) CALL trj_wri_spl(file_wop)
1302      IF ( tlm_bch == 1 ) CALL trj_wri_spl(file_xdx)
1303      !--------------------------------------------------------------------
1304      !  Compute the Tangent
1305      !--------------------------------------------------------------------
1306      IF ( tlm_bch == 2 ) THEN
1307         !--------------------------------------------------------------------
1308         ! Initialize the tangent variables
1309         !--------------------------------------------------------------------
1310         CALL  trj_rea( nit000-1, 1 ) 
1311!         CALL  trj_rea( nit000, 1 )
1312         ua(:,:,:)       = un(:,:,:)
1313         va(:,:,:)       = vn(:,:,:)
1314         gru_tl  (  :,:) = zgru_tlin (:,:  )
1315         grv_tl  (  :,:) = zgrv_tlin (:,:  )
1316         rhd_tl  (:,:,:) = zrd_tlin  (:,:,:)
1317         ua_tl   (:,:,:) = zua_tlin  (:,:,:)
1318         va_tl   (:,:,:) = zva_tlin  (:,:,:) 
1319         CALL dyn_hpg_tan(nit000)
1320         !--------------------------------------------------------------------
1321         ! Compute the scalar product: ( L(t0,tn) gamma dx0 ) )
1322         !--------------------------------------------------------------------
1323         zsp2_1    = DOT_PRODUCT( ua_tl, ua_tl  )
1324         zsp2_2    = DOT_PRODUCT( va_tl, va_tl  )
1325         zsp2      = zsp2_1 + zsp2_2
1326         !--------------------------------------------------------------------
1327         !  Storing data
1328         !--------------------------------------------------------------------
1329         CALL trj_rd_spl(file_wop) 
1330         zua_wop  (:,:,:) = ua  (:,:,:)
1331         zva_wop  (:,:,:) = va  (:,:,:)
1332         CALL trj_rd_spl(file_xdx) 
1333         zua_out  (:,:,:) = ua  (:,:,:)
1334         zva_out  (:,:,:) = va  (:,:,:)
1335         !--------------------------------------------------------------------
1336         ! Compute the Linearization Error
1337         ! Nn = M( X0+gamma.dX0, t0,tn) - M(X0, t0,tn)
1338         ! and
1339         ! Compute the Linearization Error
1340         ! En = Nn -TL(gamma.dX0, t0,tn)
1341         !--------------------------------------------------------------------
1342         ! Warning: Here we re-use local variables z()_out and z()_wop
1343         ii=0
1344         DO jk = 1, jpk
1345            DO jj = 1, jpj
1346               DO ji = 1, jpi
1347                  zua_out   (ji,jj,jk) = zua_out    (ji,jj,jk) - zua_wop  (ji,jj,jk)
1348                  zua_wop   (ji,jj,jk) = zua_out    (ji,jj,jk) - ua_tl    (ji,jj,jk)
1349                  IF (  ua_tl(ji,jj,jk) .NE. 0.0_wp ) &
1350                     & zerrua(ji,jj,jk) = zua_out(ji,jj,jk)/ua_tl(ji,jj,jk)
1351                  IF( (MOD(ji, isamp) .EQ. 0) .AND. &
1352                  &   (MOD(jj, jsamp) .EQ. 0) .AND. &
1353                  &   (MOD(jk, ksamp) .EQ. 0)     ) THEN
1354                      ii = ii+1
1355                      iiposua(ii) = ji
1356                      ijposua(ii) = jj
1357                      ikposua(ii) = jk
1358                      IF ( INT(umask(ji,jj,jk)) .NE. 0)  THEN
1359                         zscua (ii) =  zua_wop(ji,jj,jk)
1360                         zscerrua (ii) =  ( zerrua(ji,jj,jk) - 1.0_wp ) /gamma
1361                      ENDIF
1362                  ENDIF
1363               END DO
1364            END DO
1365         END DO
1366         ii=0
1367         DO jk = 1, jpk
1368            DO jj = 1, jpj
1369               DO ji = 1, jpi
1370                  zva_out   (ji,jj,jk) = zva_out    (ji,jj,jk) - zva_wop  (ji,jj,jk)
1371                  zva_wop   (ji,jj,jk) = zva_out    (ji,jj,jk) - va_tl    (ji,jj,jk)
1372                  IF (  va_tl(ji,jj,jk) .NE. 0.0_wp ) &
1373                     & zerrva(ji,jj,jk) = zva_out(ji,jj,jk)/va_tl(ji,jj,jk)
1374                  IF( (MOD(ji, isamp) .EQ. 0) .AND. &
1375                  &   (MOD(jj, jsamp) .EQ. 0) .AND. &
1376                  &   (MOD(jk, ksamp) .EQ. 0)     ) THEN
1377                      ii = ii+1
1378                      iiposva(ii) = ji
1379                      ijposva(ii) = jj
1380                      ikposva(ii) = jk
1381                      IF ( INT(vmask(ji,jj,jk)) .NE. 0)  THEN
1382                         zscva (ii) =  zua_wop(ji,jj,jk)
1383                         zscerrva (ii) =  ( zerrva(ji,jj,jk) - 1.0_wp ) / gamma
1384                      ENDIF
1385                  ENDIF
1386               END DO
1387            END DO
1388         END DO
1389         zsp1_1    = DOT_PRODUCT( zua_out, zua_out )
1390         zsp1_2    = DOT_PRODUCT( zva_out, zva_out  )
1391         zsp1      = zsp1_1 + zsp1_2
1392
1393         zsp3_1    = DOT_PRODUCT( zua_wop, zua_wop )
1394         zsp3_2    = DOT_PRODUCT( zva_wop, zva_wop  )
1395         zsp3      = zsp3_1 + zsp3_2
1396         !--------------------------------------------------------------------
1397         ! Print the linearization error En - norme 2
1398         !--------------------------------------------------------------------
1399         ! 14 char:'12345678901234'
1400         cl_name  = 'dynhpg_tam:En '
1401         zzsp     = dsqrt(zsp3)
1402         zzsp_1   = dsqrt(zsp3_1)
1403         zzsp_2   = dsqrt(zsp3_2)
1404
1405         zgsp5 = zzsp
1406         CALL prntst_tlm( cl_name, kumadt, zzsp, h_ratio )
1407         !--------------------------------------------------------------------
1408         ! Compute TLM norm2
1409         !--------------------------------------------------------------------
1410         zzsp     = SQRT(zsp2)
1411         zzsp_1   = SQRT(zsp2_1)
1412         zzsp_2   = SQRT(zsp2_2)
1413         zgsp4    = zzsp
1414         cl_name  = 'dynhpg_tam:Ln2'
1415         CALL prntst_tlm( cl_name, kumadt, zzsp, h_ratio )
1416         !--------------------------------------------------------------------
1417         ! Print the linearization error Nn - norme 2
1418         !--------------------------------------------------------------------
1419         zzsp     = SQRT(zsp1)
1420         zzsp_1   = SQRT(zsp1_1)
1421         zzsp_2   = SQRT(zsp1_2)
1422         cl_name  = 'dynhpg:Mhdx-Mx'
1423         CALL prntst_tlm( cl_name, kumadt, zzsp, h_ratio )
1424         zgsp3    = SQRT( zsp3/zsp2 )
1425         zgsp7    = zgsp3/gamma
1426         zgsp1    = zzsp
1427         zgsp2    = zgsp1 / zgsp4
1428         zgsp6    = (zgsp2 - 1.0_wp)/gamma
1429
1430         FMT = "(A8,2X,I4.4,2X,E6.1,2X,E20.13,2X,E20.13,2X,E20.13,2X,E20.13,2X,E20.13,2X,E20.13,2X,E20.13)"
1431         WRITE(numtan,FMT) 'dynhpg  ', cur_loop, h_ratio, zgsp1, zgsp2, zgsp3, zgsp4, zgsp5, zgsp6, zgsp7
1432         !--------------------------------------------------------------------
1433         ! Unitary calculus
1434         !--------------------------------------------------------------------
1435         FMT = "(A8,2X,A8,2X,I4.4,2X,E6.1,2X,I4.4,2X,I4.4,2X,I4.4,2X,E20.13,1X)"
1436         cl_name = 'dynhpg  '
1437         IF (lwp) THEN
1438            DO ii=1, 100, 1
1439               IF ( zscua(ii) .NE. 0.0_wp ) WRITE(numtan_sc,FMT) cl_name, 'zscua     ', &
1440                    & cur_loop, h_ratio, ii, iiposua(ii), ijposua(ii), zscua(ii)
1441            ENDDO
1442            DO ii=1, 100, 1
1443               IF ( zscva(ii) .NE. 0.0_wp ) WRITE(numtan_sc,FMT) cl_name, 'zscva     ', &
1444                    & cur_loop, h_ratio, ii, iiposva(ii), ijposva(ii), zscva(ii)
1445            ENDDO
1446            DO ii=1, 100, 1
1447               IF ( zscerrua(ii) .NE. 0.0_wp ) WRITE(numtan_sc,FMT) cl_name, 'zscerrua  ', &
1448                 & cur_loop, h_ratio, ii, iiposua(ii), ijposua(ii), zscerrua(ii)
1449            ENDDO
1450            DO ii=1, 100, 1
1451               IF ( zscerrva(ii) .NE. 0.0_wp ) WRITE(numtan_sc,FMT) cl_name, 'zscerrva  ', &
1452                    & cur_loop, h_ratio, ii, iiposva(ii), ijposva(ii), zscerrva(ii)
1453            ENDDO
1454
1455           ! write separator
1456           WRITE(numtan_sc,"(A4)") '===='
1457         ENDIF
1458
1459      ENDIF
1460      DEALLOCATE(                           &
1461         & zrd_tlin, zgru_tlin, zgrv_tlin,  & 
1462         & zua_tlin, zva_tlin,              & 
1463         & ztn_tlin, zsn_tlin,              & 
1464         & zua_out, zva_out,                & 
1465         & zua_wop, zva_wop,                &
1466         & zrh,                             & 
1467         & zau,                             & 
1468         & zav,                             & 
1469         & zgru,                            &
1470         & zgrv                             &
1471         & )
1472   END SUBROUTINE dyn_hpg_tlm_tst
1473   !!======================================================================
1474#endif
1475#endif
1476END MODULE dynhpg_tam
Note: See TracBrowser for help on using the repository browser.