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.
dynspg_flt.F90 in branches/2015/dev_r5803_NOC_WAD/NEMOGCM/NEMO/OPA_SRC/DYN – NEMO

source: branches/2015/dev_r5803_NOC_WAD/NEMOGCM/NEMO/OPA_SRC/DYN/dynspg_flt.F90 @ 5870

Last change on this file since 5870 was 5870, checked in by acc, 8 years ago

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