source: branches/2013/dev_r3858_CNRS3_Ediag/NEMOGCM/NEMO/OPA_SRC/DYN/dynspg_flt.F90 @ 3876

Last change on this file since 3876 was 3876, checked in by gm, 8 years ago

dev_r3858_CNRS3_Ediag: #927 phasing with 2011/dev_r3309_LOCEAN12_Ediag branche + mxl diag update

  • Property svn:keywords set to Id
File size: 21.4 KB
Line 
1MODULE dynspg_flt
2   !!======================================================================
3   !!                   ***  MODULE  dynspg_flt  ***
4   !! Ocean dynamics:  surface pressure gradient trend
5   !!======================================================================
6   !! History    OPA  !  1998-05  (G. Roullet)  free surface
7   !!                 !  1998-10  (G. Madec, M. Imbard)  release 8.2
8   !!   NEMO     O.1  !  2002-08  (G. Madec)  F90: Free form and module
9   !!             -   !  2002-11  (C. Talandier, A-M Treguier) Open boundaries
10   !!            1.0  !  2004-08  (C. Talandier) New trends organization
11   !!             -   !  2005-11  (V. Garnier) Surface pressure gradient organization
12   !!            2.0  !  2006-07  (S. Masson)  distributed restart using iom
13   !!             -   !  2006-08  (J.Chanut, A.Sellar) Calls to BDY routines.
14   !!            3.2  !  2009-03  (G. Madec, M. Leclair, R. Benshila) introduce sshwzv module
15   !!            3.5  !  2012-05  (F. Roquet, G. Madec)  add some trends diag
16   !!----------------------------------------------------------------------
17#if defined key_dynspg_flt   ||   defined key_esopa 
18   !!----------------------------------------------------------------------
19   !!   'key_dynspg_flt'                              filtered free surface
20   !!----------------------------------------------------------------------
21   !!   dyn_spg_flt  : update the momentum trend with the surface pressure gradient in the filtered free surface case
22   !!   flt_rst      : read/write the time-splitting restart fields in the ocean restart file
23   !!----------------------------------------------------------------------
24   USE oce             ! ocean dynamics and tracers
25   USE dom_oce         ! ocean space and time domain
26   USE zdf_oce         ! ocean vertical physics
27   USE sbc_oce         ! surface boundary condition: ocean
28   USE obc_oce         ! Lateral open boundary condition
29   USE bdy_oce         ! Lateral open boundary condition
30   USE sol_oce         ! ocean elliptic solver
31   USE phycst          ! physical constants
32   USE domvvl          ! variable volume
33   USE dynadv          ! advection
34   USE solmat          ! matrix construction for elliptic solvers
35   USE solpcg          ! preconditionned conjugate gradient solver
36   USE solsor          ! Successive Over-relaxation solver
37   USE obcdyn          ! ocean open boundary condition on dynamics
38   USE obcvol          ! ocean open boundary condition (obc_vol routine)
39   USE bdydyn          ! ocean open boundary condition on dynamics
40   USE bdyvol          ! ocean open boundary condition (bdy_vol routine)
41   USE cla             ! cross land advection
42   USE trd_oce         ! trends: ocean variables
43   USE trddyn          ! trend manager: dynamics
44   !
45   USE in_out_manager  ! I/O manager
46   USE lib_mpp         ! distributed memory computing library
47   USE wrk_nemo        ! Memory Allocation
48   USE lbclnk          ! ocean lateral boundary conditions (or mpp link)
49   USE prtctl          ! Print control
50   USE iom
51   USE lib_fortran
52   USE timing          ! Timing
53#if defined key_agrif
54   USE agrif_opa_interp
55#endif
56
57   IMPLICIT NONE
58   PRIVATE
59
60   PUBLIC   dyn_spg_flt  ! routine called by step.F90
61   PUBLIC   flt_rst      ! routine called by istate.F90
62
63   !! * Substitutions
64#  include "domzgr_substitute.h90"
65#  include "vectopt_loop_substitute.h90"
66   !!----------------------------------------------------------------------
67   !! NEMO/OPA 3.3 , NEMO Consortium (2010)
68   !! $Id$
69   !! Software governed by the CeCILL licence     (NEMOGCM/NEMO_CeCILL.txt)
70   !!----------------------------------------------------------------------
71CONTAINS
72
73   SUBROUTINE dyn_spg_flt( kt, kindic )
74      !!----------------------------------------------------------------------
75      !!                  ***  routine dyn_spg_flt  ***
76      !!
77      !! ** Purpose :   Compute the now trend due to the surface pressure
78      !!      gradient in case of filtered free surface formulation  and add
79      !!      it to the general trend of momentum equation.
80      !!
81      !! ** Method  :   Filtered free surface formulation. The surface
82      !!      pressure gradient is given by:
83      !!         spgu = 1/rau0 d/dx(ps) =  1/e1u di( sshn + btda )
84      !!         spgv = 1/rau0 d/dy(ps) =  1/e2v dj( sshn + btda )
85      !!      where sshn is the free surface elevation and btda is the after
86      !!      time derivative of the free surface elevation
87      !!       -1- evaluate the surface presure trend (including the addi-
88      !!      tional force) in three steps:
89      !!        a- compute the right hand side of the elliptic equation:
90      !!            gcb = 1/(e1t e2t) [ di(e2u spgu) + dj(e1v spgv) ]
91      !!         where (spgu,spgv) are given by:
92      !!            spgu = vertical sum[ e3u (ub+ 2 rdt ua ) ]
93      !!                 - grav 2 rdt hu /e1u di[sshn + (emp-rnf)]
94      !!            spgv = vertical sum[ e3v (vb+ 2 rdt va) ]
95      !!                 - grav 2 rdt hv /e2v dj[sshn + (emp-rnf)]
96      !!         and define the first guess from previous computation :
97      !!            zbtd = btda
98      !!            btda = 2 zbtd - btdb
99      !!            btdb = zbtd
100      !!        b- compute the relative accuracy to be reached by the
101      !!         iterative solver
102      !!        c- apply the solver by a call to sol... routine
103      !!       -2- compute and add the free surface pressure gradient inclu-
104      !!      ding the additional force used to stabilize the equation.
105      !!
106      !! ** Action : - Update (ua,va) with the surf. pressure gradient trend
107      !!
108      !! References : Roullet and Madec, JGR, 2000.
109      !!---------------------------------------------------------------------
110      INTEGER, INTENT(in   ) ::   kt       ! ocean time-step index
111      INTEGER, INTENT(  out) ::   kindic   ! solver convergence flag (<0 if not converge)
112      !
113      INTEGER  ::   ji, jj, jk   ! dummy loop indices
114      REAL(wp) ::   z2dt, z2dtg, zgcb, zbtd, ztdgu, ztdgv   ! local scalars
115      REAL(wp), POINTER, DIMENSION(:,:,:) ::  ztrdu, ztrdv
116      REAL(wp), POINTER, DIMENSION(:,:)   ::  zpw
117      !!----------------------------------------------------------------------
118      !
119      IF( nn_timing == 1 )  CALL timing_start('dyn_spg_flt')
120      !
121      IF( kt == nit000 ) THEN
122         IF(lwp) WRITE(numout,*)
123         IF(lwp) WRITE(numout,*) 'dyn_spg_flt : surface pressure gradient trend'
124         IF(lwp) WRITE(numout,*) '~~~~~~~~~~~   (free surface constant volume case)'
125       
126         ! set to zero free surface specific arrays
127         spgu(:,:) = 0._wp                     ! surface pressure gradient (i-direction)
128         spgv(:,:) = 0._wp                     ! surface pressure gradient (j-direction)
129
130         ! read filtered free surface arrays in restart file
131         ! when using agrif, sshn, gcx have to be read in istate
132         IF(.NOT. lk_agrif)   CALL flt_rst( nit000, 'READ' )      ! read or initialize the following fields:
133         !                                                        ! gcx, gcxb
134      ENDIF
135
136      ! Local constant initialization
137      z2dt = 2. * rdt                                             ! time step: leap-frog
138      IF( neuler == 0 .AND. kt == nit000   )   z2dt = rdt         ! time step: Euler if restart from rest
139      IF( neuler == 0 .AND. kt == nit000+1 )   CALL sol_mat( kt )
140      z2dtg  = grav * z2dt
141
142      ! Evaluate the masked next velocity (effect of the additional force not included)
143      ! --------------------------------- 
144      IF( lk_vvl ) THEN          ! variable volume  (surface pressure gradient already included in dyn_hpg)
145         !
146         IF( ln_dynadv_vec ) THEN      ! vector form : applied on velocity
147            DO jk = 1, jpkm1
148               DO jj = 2, jpjm1
149                  DO ji = fs_2, fs_jpim1   ! vector opt.
150                     ua(ji,jj,jk) = (  ub(ji,jj,jk) + z2dt * ua(ji,jj,jk)  ) * umask(ji,jj,jk)
151                     va(ji,jj,jk) = (  vb(ji,jj,jk) + z2dt * va(ji,jj,jk)  ) * vmask(ji,jj,jk)
152                  END DO
153               END DO
154            END DO
155            !
156         ELSE                          ! flux form : applied on thickness weighted velocity
157            DO jk = 1, jpkm1
158               DO jj = 2, jpjm1
159                  DO ji = fs_2, fs_jpim1   ! vector opt.
160                     ua(ji,jj,jk) = (        ub(ji,jj,jk) * fse3u_b(ji,jj,jk)      &
161                        &           + z2dt * ua(ji,jj,jk) * fse3u_n(ji,jj,jk)  )   &
162                        &         / fse3u_a(ji,jj,jk) * umask(ji,jj,jk)
163                     va(ji,jj,jk) = (        vb(ji,jj,jk) * fse3v_b(ji,jj,jk)      &
164                        &           + z2dt * va(ji,jj,jk) * fse3v_n(ji,jj,jk)  )   &
165                        &         / fse3v_a(ji,jj,jk) * vmask(ji,jj,jk)
166                 END DO
167               END DO
168            END DO
169            !
170         ENDIF
171         !
172      ELSE                       ! fixed volume  (add the surface pressure gradient + unweighted time stepping)
173         !
174         DO jj = 2, jpjm1              ! Surface pressure gradient (now)
175            DO ji = fs_2, fs_jpim1   ! vector opt.
176               spgu(ji,jj) = - grav * ( sshn(ji+1,jj) - sshn(ji,jj) ) / e1u(ji,jj)
177               spgv(ji,jj) = - grav * ( sshn(ji,jj+1) - sshn(ji,jj) ) / e2v(ji,jj)
178            END DO
179         END DO
180         DO jk = 1, jpkm1              ! unweighted time stepping
181            DO jj = 2, jpjm1
182               DO ji = fs_2, fs_jpim1   ! vector opt.
183                  ua(ji,jj,jk) = (  ub(ji,jj,jk) + z2dt * ( ua(ji,jj,jk) + spgu(ji,jj) )  ) * umask(ji,jj,jk)
184                  va(ji,jj,jk) = (  vb(ji,jj,jk) + z2dt * ( va(ji,jj,jk) + spgv(ji,jj) )  ) * vmask(ji,jj,jk)
185               END DO
186            END DO
187         END DO
188         ! save the explicit SPG trends for further diagnostics
189         ! ---------------------------------------------
190         IF( l_trddyn )   THEN                      ! temporary save of ta and sa trends
191            CALL wrk_alloc( jpi, jpj, jpk, ztrdu, ztrdv )
192            DO jk = 1, jpkm1              ! unweighted time stepping
193               DO jj = 2, jpjm1
194                  DO ji = fs_2, fs_jpim1   ! vector opt.
195                     ztrdu(ji,jj,jk) = spgu(ji,jj) * umask(ji,jj,jk)
196                     ztrdv(ji,jj,jk) = spgv(ji,jj) * vmask(ji,jj,jk)
197                  END DO
198               END DO
199            END DO
200            CALL trd_dyn( ztrdu, ztrdv, jpdyn_spgexp, kt )
201         ENDIF
202         !
203      ENDIF
204
205#if defined key_obc
206      IF( lk_obc ) CALL obc_dyn( kt )   ! Update velocities on each open boundary with the radiation algorithm
207      IF( lk_obc ) CALL obc_vol( kt )   ! Correction of the barotropic componant velocity to control the volume of the system
208#endif
209#if defined key_bdy
210      IF( lk_bdy ) CALL bdy_dyn( kt )   ! Update velocities on each open boundary
211      IF( lk_bdy ) CALL bdy_vol( kt )   ! Correction of the barotropic component velocity to control the volume of the system
212#endif
213#if defined key_agrif
214      CALL Agrif_dyn( kt )    ! Update velocities on each coarse/fine interfaces
215#endif
216      IF( nn_cla == 1 )   CALL cla_dynspg( kt )      ! Cross Land Advection (update (ua,va))
217
218      ! compute the next vertically averaged velocity (effect of the additional force not included)
219      ! ---------------------------------------------
220      DO jj = 2, jpjm1
221         DO ji = fs_2, fs_jpim1   ! vector opt.
222            spgu(ji,jj) = 0._wp
223            spgv(ji,jj) = 0._wp
224         END DO
225      END DO
226
227      !                                    ! vertical sum
228!CDIR NOLOOPCHG
229      IF( lk_vopt_loop ) THEN          ! vector opt., forced unroll
230         DO jk = 1, jpkm1
231            DO ji = 1, jpij
232               spgu(ji,1) = spgu(ji,1) + fse3u(ji,1,jk) * ua(ji,1,jk)
233               spgv(ji,1) = spgv(ji,1) + fse3v(ji,1,jk) * va(ji,1,jk)
234            END DO
235         END DO
236      ELSE                                      ! No  vector opt.
237         DO jk = 1, jpkm1
238            DO jj = 2, jpjm1
239               DO ji = 2, jpim1
240                  spgu(ji,jj) = spgu(ji,jj) + fse3u(ji,jj,jk) * ua(ji,jj,jk)
241                  spgv(ji,jj) = spgv(ji,jj) + fse3v(ji,jj,jk) * va(ji,jj,jk)
242               END DO
243            END DO
244         END DO
245      ENDIF
246
247      DO jj = 2, jpjm1                     ! transport: multiplied by the horizontal scale factor
248         DO ji = fs_2, fs_jpim1   ! vector opt.
249            spgu(ji,jj) = spgu(ji,jj) * e2u(ji,jj)
250            spgv(ji,jj) = spgv(ji,jj) * e1v(ji,jj)
251         END DO
252      END DO
253      CALL lbc_lnk( spgu, 'U', -1. )       ! lateral boundary conditions
254      CALL lbc_lnk( spgv, 'V', -1. )
255
256      IF( lk_vvl ) CALL sol_mat( kt )      ! build the matrix at kt (vvl case only)
257
258      ! Right hand side of the elliptic equation and first guess
259      ! --------------------------------------------------------
260      DO jj = 2, jpjm1
261         DO ji = fs_2, fs_jpim1   ! vector opt.
262            ! Divergence of the after vertically averaged velocity
263            zgcb =  spgu(ji,jj) - spgu(ji-1,jj)   &
264                  + spgv(ji,jj) - spgv(ji,jj-1)
265            gcb(ji,jj) = gcdprc(ji,jj) * zgcb
266            ! First guess of the after barotropic transport divergence
267            zbtd = gcx(ji,jj)
268            gcx (ji,jj) = 2. * zbtd   - gcxb(ji,jj)
269            gcxb(ji,jj) =      zbtd
270         END DO
271      END DO
272      ! applied the lateral boundary conditions
273      IF( nn_solv == 2 .AND. MAX( jpr2di, jpr2dj ) > 0 )   CALL lbc_lnk_e( gcb, c_solver_pt, 1., jpr2di, jpr2dj )   
274
275#if defined key_agrif
276      IF( .NOT. AGRIF_ROOT() ) THEN
277         ! add contribution of gradient of after barotropic transport divergence
278         IF( nbondi == -1 .OR. nbondi == 2 )   gcb(3     ,:) =   &
279            &    gcb(3     ,:) - z2dtg * z2dt * laplacu(2     ,:) * gcdprc(3     ,:) * hu(2     ,:) * e2u(2     ,:)
280         IF( nbondi ==  1 .OR. nbondi == 2 )   gcb(nlci-2,:) =   &
281            &    gcb(nlci-2,:) + z2dtg * z2dt * laplacu(nlci-2,:) * gcdprc(nlci-2,:) * hu(nlci-2,:) * e2u(nlci-2,:)
282         IF( nbondj == -1 .OR. nbondj == 2 )   gcb(:     ,3) =   &
283            &    gcb(:,3     ) - z2dtg * z2dt * laplacv(:,2     ) * gcdprc(:,3     ) * hv(:,2     ) * e1v(:,2     )
284         IF( nbondj ==  1 .OR. nbondj == 2 )   gcb(:,nlcj-2) =   &
285            &    gcb(:,nlcj-2) + z2dtg * z2dt * laplacv(:,nlcj-2) * gcdprc(:,nlcj-2) * hv(:,nlcj-2) * e1v(:,nlcj-2)
286      ENDIF
287#endif
288
289
290      ! Relative precision (computation on one processor)
291      ! ------------------
292      rnorme =0.e0
293      rnorme = GLOB_SUM( gcb(1:jpi,1:jpj) * gcdmat(1:jpi,1:jpj) * gcb(1:jpi,1:jpj) * bmask(:,:) )
294
295      epsr = eps * eps * rnorme
296      ncut = 0
297      ! if rnorme is 0, the solution is 0, the solver is not called
298      IF( rnorme == 0._wp ) THEN
299         gcx(:,:) = 0._wp
300         res   = 0._wp
301         niter = 0
302         ncut  = 999
303      ENDIF
304
305      ! Evaluate the next transport divergence
306      ! --------------------------------------
307      !    Iterarive solver for the elliptic equation (except IF sol.=0)
308      !    (output in gcx with boundary conditions applied)
309      kindic = 0
310      IF( ncut == 0 ) THEN
311         IF    ( nn_solv == 1 ) THEN   ;   CALL sol_pcg( kindic )      ! diagonal preconditioned conjuguate gradient
312         ELSEIF( nn_solv == 2 ) THEN   ;   CALL sol_sor( kindic )      ! successive-over-relaxation
313         ENDIF
314      ENDIF
315
316      ! Transport divergence gradient multiplied by z2dt
317      ! --------------------------------------------====
318      DO jj = 2, jpjm1
319         DO ji = fs_2, fs_jpim1   ! vector opt.
320            ! trend of Transport divergence gradient
321            ztdgu = z2dtg * (gcx(ji+1,jj  ) - gcx(ji,jj) ) / e1u(ji,jj)
322            ztdgv = z2dtg * (gcx(ji  ,jj+1) - gcx(ji,jj) ) / e2v(ji,jj)
323            ! multiplied by z2dt
324#if defined key_obc
325            IF(lk_obc) THEN
326            ! caution : grad D = 0 along open boundaries
327            ! Remark: The filtering force could be reduced here in the FRS zone
328            !         by multiplying spgu/spgv by (1-alpha) ?? 
329               spgu(ji,jj) = z2dt * ztdgu * obcumask(ji,jj)
330               spgv(ji,jj) = z2dt * ztdgv * obcvmask(ji,jj)
331            ELSE
332               spgu(ji,jj) = z2dt * ztdgu
333               spgv(ji,jj) = z2dt * ztdgv
334            ENDIF
335#elif defined key_bdy
336            IF(lk_bdy) THEN
337            ! caution : grad D = 0 along open boundaries
338               spgu(ji,jj) = z2dt * ztdgu * bdyumask(ji,jj)
339               spgv(ji,jj) = z2dt * ztdgv * bdyvmask(ji,jj)
340            ELSE
341               spgu(ji,jj) = z2dt * ztdgu
342               spgv(ji,jj) = z2dt * ztdgv
343            ENDIF
344#else
345            spgu(ji,jj) = z2dt * ztdgu
346            spgv(ji,jj) = z2dt * ztdgv
347#endif
348         END DO
349      END DO
350
351#if defined key_agrif     
352      IF( .NOT. Agrif_Root() ) THEN
353         ! caution : grad D (fine) = grad D (coarse) at coarse/fine interface
354         IF( nbondi == -1 .OR. nbondi == 2 ) spgu(2     ,:) = z2dtg * z2dt * laplacu(2     ,:) * umask(2     ,:,1)
355         IF( nbondi ==  1 .OR. nbondi == 2 ) spgu(nlci-2,:) = z2dtg * z2dt * laplacu(nlci-2,:) * umask(nlci-2,:,1)
356         IF( nbondj == -1 .OR. nbondj == 2 ) spgv(:,2     ) = z2dtg * z2dt * laplacv(:,2     ) * vmask(:     ,2,1)
357         IF( nbondj ==  1 .OR. nbondj == 2 ) spgv(:,nlcj-2) = z2dtg * z2dt * laplacv(:,nlcj-2) * vmask(:,nlcj-2,1)
358      ENDIF
359#endif     
360
361      IF( l_trddyn )   THEN                     
362         ztrdu(:,:,:) = ua(:,:,:)                 ! save the after velocity before the filtered SPG
363         ztrdv(:,:,:) = va(:,:,:)
364         !
365         CALL wrk_alloc( jpi, jpj, zpw )
366         !
367         zpw(:,:) = - z2dt * gcx(:,:)
368         CALL iom_put( "ssh_flt" , zpw )          ! output equivalent ssh modification due to implicit filter
369         !
370         !                                        ! save surface pressure flux: -pw at z=0
371         zpw(:,:) = - rau0 * grav * sshn(:,:) * wn(:,:,1) * tmask(:,:,1)
372         CALL iom_put( "pw0_exp" , zpw )
373         zpw(:,:) = wn(:,:,1)
374         CALL iom_put( "w0" , zpw )
375         zpw(:,:) =  rau0 * z2dtg * gcx(:,:) * wn(:,:,1) * tmask(:,:,1)
376         CALL iom_put( "pw0_flt" , zpw )
377         !
378         CALL wrk_dealloc( jpi, jpj, zpw ) 
379         !                                   
380      ENDIF
381     
382      ! Add the trends multiplied by z2dt to the after velocity
383      ! -------------------------------------------------------
384      !     ( c a u t i o n : (ua,va) here are the after velocity not the
385      !                       trend, the leap-frog time stepping will not
386      !                       be done in dynnxt.F90 routine)
387      DO jk = 1, jpkm1
388         DO jj = 2, jpjm1
389            DO ji = fs_2, fs_jpim1   ! vector opt.
390               ua(ji,jj,jk) = ( ua(ji,jj,jk) + spgu(ji,jj) ) * umask(ji,jj,jk)
391               va(ji,jj,jk) = ( va(ji,jj,jk) + spgv(ji,jj) ) * vmask(ji,jj,jk)
392            END DO
393         END DO
394      END DO
395
396      IF( l_trddyn )   THEN                      ! save the explicit SPG trends for further diagnostics
397         ztrdu(:,:,:) = ( ua(:,:,:) - ztrdu(:,:,:) ) / z2dt
398         ztrdv(:,:,:) = ( va(:,:,:) - ztrdv(:,:,:) ) / z2dt
399         CALL trd_dyn( ztrdu, ztrdv, jpdyn_spgflt, kt )
400         !
401         CALL wrk_dealloc( jpi, jpj, jpk, ztrdu, ztrdv ) 
402      ENDIF
403
404      IF( lrst_oce )   CALL flt_rst( kt, 'WRITE' )      ! write filtered free surface arrays in restart file
405      !
406      IF( nn_timing == 1 )  CALL timing_stop('dyn_spg_flt')
407      !
408   END SUBROUTINE dyn_spg_flt
409
410
411   SUBROUTINE flt_rst( kt, cdrw )
412      !!---------------------------------------------------------------------
413      !!                   ***  ROUTINE ts_rst  ***
414      !!
415      !! ** Purpose : Read or write filtered free surface arrays in restart file
416      !!----------------------------------------------------------------------
417      INTEGER         , INTENT(in) ::   kt     ! ocean time-step
418      CHARACTER(len=*), INTENT(in) ::   cdrw   ! "READ"/"WRITE" flag
419      !!----------------------------------------------------------------------
420      !
421      IF( TRIM(cdrw) == 'READ' ) THEN
422         IF( iom_varid( numror, 'gcx', ldstop = .FALSE. ) > 0 ) THEN
423! Caution : extra-hallow
424! gcx and gcxb are defined as: DIMENSION(1-jpr2di:jpi+jpr2di,1-jpr2dj:jpj+jpr2dj)
425            CALL iom_get( numror, jpdom_autoglo, 'gcx' , gcx (1:jpi,1:jpj) )
426            CALL iom_get( numror, jpdom_autoglo, 'gcxb', gcxb(1:jpi,1:jpj) )
427            IF( neuler == 0 )   gcxb(:,:) = gcx (:,:)
428         ELSE
429            gcx (:,:) = 0.e0
430            gcxb(:,:) = 0.e0
431         ENDIF
432      ELSEIF( TRIM(cdrw) == 'WRITE' ) THEN
433! Caution : extra-hallow
434! gcx and gcxb are defined as: DIMENSION(1-jpr2di:jpi+jpr2di,1-jpr2dj:jpj+jpr2dj)
435         CALL iom_rstput( kt, nitrst, numrow, 'gcx' , gcx (1:jpi,1:jpj) )
436         CALL iom_rstput( kt, nitrst, numrow, 'gcxb', gcxb(1:jpi,1:jpj) )
437      ENDIF
438      !
439   END SUBROUTINE flt_rst
440
441#else
442   !!----------------------------------------------------------------------
443   !!   Default case :   Empty module   No standart free surface cst volume
444   !!----------------------------------------------------------------------
445CONTAINS
446   SUBROUTINE dyn_spg_flt( kt, kindic )       ! Empty routine
447      WRITE(*,*) 'dyn_spg_flt: You should not have seen this print! error?', kt, kindic
448   END SUBROUTINE dyn_spg_flt
449   SUBROUTINE flt_rst    ( kt, cdrw )         ! Empty routine
450      INTEGER         , INTENT(in) ::   kt         ! ocean time-step
451      CHARACTER(len=*), INTENT(in) ::   cdrw       ! "READ"/"WRITE" flag
452      WRITE(*,*) 'flt_rst: You should not have seen this print! error?', kt, cdrw
453   END SUBROUTINE flt_rst
454#endif
455   
456   !!======================================================================
457END MODULE dynspg_flt
Note: See TracBrowser for help on using the repository browser.