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 @ 1885

Last change on this file since 1885 was 1885, checked in by rblod, 14 years ago

add TAM sources

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