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.
flo4rk.F90 in NEMO/branches/UKMO/NEMO_4.0_mirror_text_diagnostics/src/OCE/FLO – NEMO

source: NEMO/branches/UKMO/NEMO_4.0_mirror_text_diagnostics/src/OCE/FLO/flo4rk.F90 @ 10986

Last change on this file since 10986 was 10986, checked in by andmirek, 5 years ago

GMED 462 add flush

File size: 18.8 KB
Line 
1MODULE flo4rk
2   !!======================================================================
3   !!                    ***  MODULE  flo4rk  ***
4   !! Ocean floats :   trajectory computation using a 4th order Runge-Kutta
5   !!======================================================================
6#if   defined key_floats
7   !!----------------------------------------------------------------------
8   !!   'key_floats'                                     float trajectories
9   !!----------------------------------------------------------------------
10   !!   flo_4rk        : Compute the geographical position of floats
11   !!   flo_interp     : interpolation
12   !!----------------------------------------------------------------------
13   USE flo_oce         ! ocean drifting floats
14   USE oce             ! ocean dynamics and tracers
15   USE dom_oce         ! ocean space and time domain
16   USE in_out_manager  ! I/O manager
17
18   IMPLICIT NONE
19   PRIVATE
20
21   PUBLIC   flo_4rk    ! routine called by floats.F90
22
23   !                                   ! RK4 and Lagrange interpolation coefficients
24   REAL(wp), DIMENSION (4) ::   tcoef1 = (/  1.0  ,  0.5  ,  0.5  ,  0.0  /)   !
25   REAL(wp), DIMENSION (4) ::   tcoef2 = (/  0.0  ,  0.5  ,  0.5  ,  1.0  /)   !
26   REAL(wp), DIMENSION (4) ::   scoef2 = (/  1.0  ,  2.0  ,  2.0  ,  1.0  /)   !
27   REAL(wp), DIMENSION (4) ::   rcoef  = (/-1./6. , 1./2. ,-1./2. , 1./6. /)   !
28   REAL(wp), DIMENSION (3) ::   scoef1 = (/  0.5  ,  0.5  ,  1.0  /)           !
29
30   !!----------------------------------------------------------------------
31   !! NEMO/OCE 4.0 , NEMO Consortium (2018)
32   !! $Id$
33   !! Software governed by the CeCILL license (see ./LICENSE)
34   !!----------------------------------------------------------------------
35CONTAINS
36
37   SUBROUTINE flo_4rk( kt )
38      !!----------------------------------------------------------------------
39      !!                  ***  ROUTINE flo_4rk  ***
40      !!
41      !!  ** Purpose :   Compute the geographical position (lat,lon,depth)
42      !!       of each float at each time step.
43      !!
44      !!  ** Method  :   The position of a float is computed with a 4th order
45      !!       Runge-Kutta scheme and and Lagrange interpolation.
46      !!         We need to know the velocity field, the old positions of the
47      !!       floats and the grid defined on the domain.
48      !!----------------------------------------------------------------------
49      INTEGER, INTENT(in) ::   kt   ! ocean time-step index
50      !!
51      INTEGER ::  jfl, jind           ! dummy loop indices
52      INTEGER ::  ierror              ! error value
53
54      REAL(wp), DIMENSION(jpnfl)   ::   zgifl , zgjfl , zgkfl    ! index RK  positions
55      REAL(wp), DIMENSION(jpnfl)   ::   zufl  , zvfl  , zwfl     ! interpolated velocity at the float position
56      REAL(wp), DIMENSION(jpnfl,4) ::   zrkxfl, zrkyfl, zrkzfl   ! RK coefficients
57      !!---------------------------------------------------------------------
58      !
59      IF( ierror /= 0 ) THEN
60         IF(lwp) THEN
61            WRITE(numout,*) 'flo_4rk: allocation of workspace arrays failed'
62            IF(lflush) CALL FLUSH(numout)
63         ENDIF
64      ENDIF
65
66   
67      IF( kt == nit000 .AND. lwp) THEN
68         WRITE(numout,*)
69         WRITE(numout,*) 'flo_4rk : compute Runge Kutta trajectories for floats '
70         WRITE(numout,*) '~~~~~~~'
71         IF(lflush) CALL FLUSH(numout)
72      ENDIF
73
74      ! Verification of the floats positions. If one of them leave the domain
75      ! domain we replace the float near the border.
76      DO jfl = 1, jpnfl
77         ! i-direction
78         IF( tpifl(jfl) <= 1.5 ) THEN
79            IF(lwp)WRITE(numout,*)'!!!!!!!!!!!!! WARNING !!!!!!!!!!!!!!!!'
80            IF(lwp)WRITE(numout,*)'The float',jfl,'is out of the domain at the WEST border.'
81            tpifl(jfl) = tpifl(jfl) + 1.
82            IF(lwp)WRITE(numout,*)'New initialisation for this float at i=',tpifl(jfl)
83         ENDIF
84         
85         IF( tpifl(jfl) >= jpi-.5 ) THEN
86            IF(lwp)WRITE(numout,*)'!!!!!!!!!!!!! WARNING !!!!!!!!!!!!!!!!'
87            IF(lwp)WRITE(numout,*)'The float',jfl,'is out of the domain at the EAST border.'
88            tpifl(jfl) = tpifl(jfl) - 1.
89            IF(lwp)WRITE(numout,*)'New initialisation for this float at i=', tpifl(jfl)
90         ENDIF
91         ! j-direction
92         IF( tpjfl(jfl) <= 1.5 ) THEN
93            IF(lwp)WRITE(numout,*)'!!!!!!!!!!!!! WARNING !!!!!!!!!!!!!!!!'
94            IF(lwp)WRITE(numout,*)'The float',jfl,'is out of the domain at the SOUTH border.'
95            tpjfl(jfl) = tpjfl(jfl) + 1.
96            IF(lwp)WRITE(numout,*)'New initialisation for this float at j=', tpjfl(jfl)
97         ENDIF
98           
99         IF( tpjfl(jfl) >= jpj-.5 ) THEN
100            IF(lwp)WRITE(numout,*)'!!!!!!!!!!!!! WARNING !!!!!!!!!!!!!!!!'
101            IF(lwp)WRITE(numout,*)'The float',jfl,'is out of the domain at the NORTH border.'
102            tpjfl(jfl) = tpjfl(jfl) - 1.
103            IF(lwp)WRITE(numout,*)'New initialisation for this float at j=', tpjfl(jfl)
104         ENDIF
105         ! k-direction
106         IF( tpkfl(jfl) <= .5 ) THEN
107            IF(lwp)WRITE(numout,*)'!!!!!!!!!!!!! WARNING !!!!!!!!!!!!!!!!'
108            IF(lwp)WRITE(numout,*)'The float',jfl,'is out of the domain at the TOP border.'
109            tpkfl(jfl) = tpkfl(jfl) + 1.
110            IF(lwp)WRITE(numout,*)'New initialisation for this float at k=', tpkfl(jfl)
111         ENDIF
112         
113         IF( tpkfl(jfl) >= jpk-.5 )  THEN
114            IF(lwp)WRITE(numout,*)'!!!!!!!!!!!!! WARNING !!!!!!!!!!!!!!!!'
115            IF(lwp)WRITE(numout,*)'The float',jfl,'is out of the domain at the BOTTOM border.'
116            tpkfl(jfl) = tpkfl(jfl) - 1.
117            IF(lwp)WRITE(numout,*)'New initialisation for this float at k=', tpkfl(jfl)
118         ENDIF
119      END DO
120     
121      IF(lflush .AND. lwp) CALL FLUSH(numout)
122     
123      ! 4 steps of Runge-Kutta algorithme
124      ! initialisation of the positions
125     
126      DO jfl = 1, jpnfl
127         zgifl(jfl) = tpifl(jfl)
128         zgjfl(jfl) = tpjfl(jfl)
129         zgkfl(jfl) = tpkfl(jfl)
130      END DO
131       
132      DO  jind = 1, 4         
133     
134         ! for each step we compute the compute the velocity with Lagrange interpolation
135         CALL flo_interp( zgifl, zgjfl, zgkfl, zufl, zvfl, zwfl, jind )
136         
137         ! computation of Runge-Kutta factor
138         DO jfl = 1, jpnfl
139            zrkxfl(jfl,jind) = rdt*zufl(jfl)
140            zrkyfl(jfl,jind) = rdt*zvfl(jfl)
141            zrkzfl(jfl,jind) = rdt*zwfl(jfl)
142         END DO
143         IF( jind /= 4 ) THEN
144            DO jfl = 1, jpnfl
145               zgifl(jfl) = (tpifl(jfl)) + scoef1(jind)*zrkxfl(jfl,jind)
146               zgjfl(jfl) = (tpjfl(jfl)) + scoef1(jind)*zrkyfl(jfl,jind)
147               zgkfl(jfl) = (tpkfl(jfl)) + scoef1(jind)*zrkzfl(jfl,jind)
148            END DO
149         ENDIF
150      END DO
151      DO jind = 1, 4
152         DO jfl = 1, jpnfl
153            tpifl(jfl) = tpifl(jfl) + scoef2(jind)*zrkxfl(jfl,jind)/6.
154            tpjfl(jfl) = tpjfl(jfl) + scoef2(jind)*zrkyfl(jfl,jind)/6.
155            tpkfl(jfl) = tpkfl(jfl) + scoef2(jind)*zrkzfl(jfl,jind)/6.
156         END DO
157      END DO
158      !
159      !
160   END SUBROUTINE flo_4rk
161
162
163   SUBROUTINE flo_interp( pxt , pyt , pzt ,      &
164      &                   pufl, pvfl, pwfl, ki )
165      !!----------------------------------------------------------------------
166      !!                ***  ROUTINE flointerp  ***
167      !!
168      !! ** Purpose :   Interpolation of the velocity on the float position
169      !!
170      !! ** Method  :   Lagrange interpolation with the 64 neighboring
171      !!      points. This routine is call 4 time at each time step to
172      !!      compute velocity at the date and the position we need to
173      !!      integrated with RK method.
174      !!----------------------------------------------------------------------
175      REAL(wp) , DIMENSION(jpnfl), INTENT(in   ) ::   pxt , pyt , pzt    ! position of the float
176      REAL(wp) , DIMENSION(jpnfl), INTENT(  out) ::   pufl, pvfl, pwfl   ! velocity at this position
177      INTEGER                    , INTENT(in   ) ::   ki                 !
178      !!
179      INTEGER  ::   jfl, jind1, jind2, jind3   ! dummy loop indices
180      REAL(wp) ::   zsumu, zsumv, zsumw        ! local scalar
181      INTEGER  , DIMENSION(jpnfl)       ::   iilu, ijlu, iklu   ! nearest neighbour INDEX-u
182      INTEGER  , DIMENSION(jpnfl)       ::   iilv, ijlv, iklv   ! nearest neighbour INDEX-v
183      INTEGER  , DIMENSION(jpnfl)       ::   iilw, ijlw, iklw   ! nearest neighbour INDEX-w
184      INTEGER  , DIMENSION(jpnfl,4)     ::   iidu, ijdu, ikdu   ! 64 nearest neighbour INDEX-u
185      INTEGER  , DIMENSION(jpnfl,4)     ::   iidv, ijdv, ikdv   ! 64 nearest neighbour INDEX-v
186      INTEGER  , DIMENSION(jpnfl,4)     ::   iidw, ijdw, ikdw   ! 64 nearest neighbour INDEX-w
187      REAL(wp) , DIMENSION(jpnfl,4)     ::   zlagxu, zlagyu, zlagzu   ! Lagrange  coefficients
188      REAL(wp) , DIMENSION(jpnfl,4)     ::   zlagxv, zlagyv, zlagzv   !    -           -
189      REAL(wp) , DIMENSION(jpnfl,4)     ::   zlagxw, zlagyw, zlagzw   !    -           -
190      REAL(wp) , DIMENSION(jpnfl,4,4,4) ::   ztufl , ztvfl , ztwfl   ! velocity at choosen time step
191      !!---------------------------------------------------------------------
192 
193      ! Interpolation of U velocity
194
195      ! nearest neightboring point for computation of u       
196      DO jfl = 1, jpnfl
197         iilu(jfl) = INT(pxt(jfl)-.5)
198         ijlu(jfl) = INT(pyt(jfl)-.5)
199         iklu(jfl) = INT(pzt(jfl))
200      END DO
201     
202      !  64 neightboring points for computation of u
203      DO jind1 = 1, 4
204         DO jfl = 1, jpnfl
205            !  i-direction
206            IF( iilu(jfl) <= 2 ) THEN          ;   iidu(jfl,jind1) = jind1
207            ELSE
208               IF( iilu(jfl) >= jpi-1 ) THEN   ;   iidu(jfl,jind1) = jpi       + jind1 - 4
209               ELSE                            ;   iidu(jfl,jind1) = iilu(jfl) + jind1 - 2
210               ENDIF
211            ENDIF
212            !  j-direction
213            IF( ijlu(jfl) <= 2 ) THEN          ;   ijdu(jfl,jind1) = jind1
214            ELSE
215               IF( ijlu(jfl) >= jpj-1 ) THEN   ;   ijdu(jfl,jind1) = jpj       + jind1 - 4
216               ELSE                            ;   ijdu(jfl,jind1) = ijlu(jfl) + jind1 - 2
217               ENDIF
218            ENDIF
219            ! k-direction
220            IF( iklu(jfl) <= 2 ) THEN          ;   ikdu(jfl,jind1) = jind1
221            ELSE
222               IF( iklu(jfl) >= jpk-1 ) THEN   ;   ikdu(jfl,jind1) = jpk + jind1 - 4
223               ELSE                            ;   ikdu(jfl,jind1) = iklu(jfl) + jind1 - 2
224               ENDIF
225            ENDIF
226         END DO
227      END DO
228     
229      ! Lagrange coefficients
230      DO jfl = 1, jpnfl
231         DO jind1 = 1, 4
232            zlagxu(jfl,jind1) = 1.
233            zlagyu(jfl,jind1) = 1.
234            zlagzu(jfl,jind1) = 1.
235         END DO
236      END DO
237      DO jind1 = 1, 4
238         DO jind2 = 1, 4
239            DO jfl= 1, jpnfl
240               IF( jind1 /= jind2 ) THEN
241                  zlagxu(jfl,jind1) = zlagxu(jfl,jind1) * ( pxt(jfl)-(float(iidu(jfl,jind2))+.5) )
242                  zlagyu(jfl,jind1) = zlagyu(jfl,jind1) * ( pyt(jfl)-(float(ijdu(jfl,jind2))) )
243                  zlagzu(jfl,jind1) = zlagzu(jfl,jind1) * ( pzt(jfl)-(float(ikdu(jfl,jind2))) )
244               ENDIF
245            END DO
246         END DO
247      END DO
248     
249      ! velocity when we compute at middle time step
250     
251      DO jfl = 1, jpnfl
252         DO jind1 = 1, 4
253            DO jind2 = 1, 4
254               DO jind3 = 1, 4
255                  ztufl(jfl,jind1,jind2,jind3) =   &
256                     &   (  tcoef1(ki) * ub(iidu(jfl,jind1),ijdu(jfl,jind2),ikdu(jfl,jind3)) +   &
257                     &      tcoef2(ki) * un(iidu(jfl,jind1),ijdu(jfl,jind2),ikdu(jfl,jind3)) )   &
258                     &      / e1u(iidu(jfl,jind1),ijdu(jfl,jind2)) 
259               END DO
260            END DO
261         END DO
262         
263         zsumu = 0.
264         DO jind1 = 1, 4
265            DO jind2 = 1, 4
266               DO jind3 = 1, 4
267                  zsumu = zsumu + ztufl(jfl,jind1,jind2,jind3) * zlagxu(jfl,jind1) * zlagyu(jfl,jind2)   &
268                     &  * zlagzu(jfl,jind3) * rcoef(jind1)*rcoef(jind2)*rcoef(jind3) 
269               END DO
270            END DO
271         END DO
272         pufl(jfl) = zsumu
273      END DO
274     
275      ! Interpolation of V velocity
276
277      ! nearest neightboring point for computation of v
278      DO jfl = 1, jpnfl
279         iilv(jfl) = INT(pxt(jfl)-.5)
280         ijlv(jfl) = INT(pyt(jfl)-.5)
281         iklv(jfl) = INT(pzt(jfl))
282      END DO
283     
284      ! 64 neightboring points for computation of v
285      DO jind1 = 1, 4
286         DO jfl = 1, jpnfl
287            ! i-direction
288            IF( iilv(jfl) <= 2 ) THEN          ;   iidv(jfl,jind1) = jind1
289            ELSE
290               IF( iilv(jfl) >= jpi-1 ) THEN   ;   iidv(jfl,jind1) = jpi       + jind1 - 4
291               ELSE                            ;   iidv(jfl,jind1) = iilv(jfl) + jind1 - 2
292               ENDIF
293            ENDIF
294            ! j-direction
295            IF( ijlv(jfl) <= 2 ) THEN          ;   ijdv(jfl,jind1) = jind1
296            ELSE
297               IF( ijlv(jfl) >= jpj-1 ) THEN   ;   ijdv(jfl,jind1) = jpj       + jind1 - 4
298               ELSE                            ;   ijdv(jfl,jind1) = ijlv(jfl) + jind1 - 2
299               ENDIF
300            ENDIF
301            ! k-direction
302            IF( iklv(jfl) <= 2 ) THEN          ;   ikdv(jfl,jind1) = jind1
303            ELSE
304               IF( iklv(jfl) >= jpk-1 ) THEN   ;   ikdv(jfl,jind1) = jpk + jind1 - 4
305               ELSE                            ;   ikdv(jfl,jind1) = iklv(jfl) + jind1 - 2
306               ENDIF
307            ENDIF
308         END DO
309      END DO
310     
311      ! Lagrange coefficients
312     
313      DO jfl = 1, jpnfl
314         DO jind1 = 1, 4
315            zlagxv(jfl,jind1) = 1.
316            zlagyv(jfl,jind1) = 1.
317            zlagzv(jfl,jind1) = 1.
318         END DO
319      END DO
320     
321      DO jind1 = 1, 4
322         DO jind2 = 1, 4
323            DO jfl = 1, jpnfl
324               IF( jind1 /= jind2 ) THEN
325                  zlagxv(jfl,jind1)= zlagxv(jfl,jind1)*(pxt(jfl) - (float(iidv(jfl,jind2))   ) )
326                  zlagyv(jfl,jind1)= zlagyv(jfl,jind1)*(pyt(jfl) - (float(ijdv(jfl,jind2))+.5) )
327                  zlagzv(jfl,jind1)= zlagzv(jfl,jind1)*(pzt(jfl) - (float(ikdv(jfl,jind2))   ) )
328               ENDIF
329            END DO
330         END DO
331      END DO
332     
333      ! velocity when we compute at middle time step
334     
335      DO jfl = 1, jpnfl
336         DO jind1 = 1, 4
337            DO jind2 = 1, 4
338               DO jind3 = 1 ,4
339                  ztvfl(jfl,jind1,jind2,jind3)=   &
340                     &   ( tcoef1(ki) * vb(iidv(jfl,jind1),ijdv(jfl,jind2),ikdv(jfl,jind3))  +   &
341                     &     tcoef2(ki) * vn(iidv(jfl,jind1),ijdv(jfl,jind2),ikdv(jfl,jind3)) )    & 
342                     &     / e2v(iidv(jfl,jind1),ijdv(jfl,jind2))
343               END DO
344            END DO
345         END DO
346         
347         zsumv=0.
348         DO jind1 = 1, 4
349            DO jind2 = 1, 4
350               DO jind3 = 1, 4
351                  zsumv = zsumv + ztvfl(jfl,jind1,jind2,jind3) * zlagxv(jfl,jind1) * zlagyv(jfl,jind2)   &
352                     &  * zlagzv(jfl,jind3) * rcoef(jind1)*rcoef(jind2)*rcoef(jind3)
353               END DO
354            END DO
355         END DO
356         pvfl(jfl) = zsumv
357      END DO
358     
359      ! Interpolation of W velocity
360
361      ! nearest neightboring point for computation of w
362      DO jfl = 1, jpnfl
363         iilw(jfl) = INT( pxt(jfl)   )
364         ijlw(jfl) = INT( pyt(jfl)   )
365         iklw(jfl) = INT( pzt(jfl)+.5)
366      END DO
367     
368      ! 64 neightboring points for computation of w
369      DO jind1 = 1, 4
370         DO jfl = 1, jpnfl
371            ! i-direction
372            IF( iilw(jfl) <= 2 ) THEN          ;   iidw(jfl,jind1) = jind1
373            ELSE
374               IF( iilw(jfl) >= jpi-1 ) THEN   ;   iidw(jfl,jind1) = jpi       + jind1 - 4
375               ELSE                            ;   iidw(jfl,jind1) = iilw(jfl) + jind1 - 2
376               ENDIF
377            ENDIF
378            ! j-direction
379            IF( ijlw(jfl) <= 2 ) THEN          ;   ijdw(jfl,jind1) = jind1
380            ELSE
381               IF( ijlw(jfl) >= jpj-1 ) THEN   ;   ijdw(jfl,jind1) = jpj       + jind1 - 4
382               ELSE                            ;   ijdw(jfl,jind1) = ijlw(jfl) + jind1 - 2
383               ENDIF
384            ENDIF
385            ! k-direction
386            IF( iklw(jfl) <= 2 ) THEN          ;   ikdw(jfl,jind1) = jind1
387            ELSE
388               IF( iklw(jfl) >= jpk-1 ) THEN   ;   ikdw(jfl,jind1) = jpk       + jind1 - 4
389               ELSE                            ;   ikdw(jfl,jind1) = iklw(jfl) + jind1 - 2
390               ENDIF
391            ENDIF
392         END DO
393      END DO
394      DO jind1 = 1, 4
395         DO jfl = 1, jpnfl
396            IF( iklw(jfl) <= 2 ) THEN          ;   ikdw(jfl,jind1) = jind1
397            ELSE
398               IF( iklw(jfl) >= jpk-1 ) THEN   ;   ikdw(jfl,jind1) = jpk       + jind1 - 4
399               ELSE                            ;   ikdw(jfl,jind1) = iklw(jfl) + jind1 - 2
400               ENDIF
401            ENDIF
402         END DO
403      END DO
404     
405      ! Lagrange coefficients  for w interpolation
406      DO jfl = 1, jpnfl
407         DO jind1 = 1, 4
408            zlagxw(jfl,jind1) = 1.
409            zlagyw(jfl,jind1) = 1.
410            zlagzw(jfl,jind1) = 1.
411         END DO
412      END DO
413      DO jind1 = 1, 4
414         DO jind2 = 1, 4
415            DO jfl = 1, jpnfl
416               IF( jind1 /= jind2 ) THEN
417                  zlagxw(jfl,jind1) = zlagxw(jfl,jind1) * (pxt(jfl) - (float(iidw(jfl,jind2))   ) )
418                  zlagyw(jfl,jind1) = zlagyw(jfl,jind1) * (pyt(jfl) - (float(ijdw(jfl,jind2))   ) )
419                  zlagzw(jfl,jind1) = zlagzw(jfl,jind1) * (pzt(jfl) - (float(ikdw(jfl,jind2))-.5) )
420               ENDIF
421            END DO
422         END DO
423      END DO
424     
425      ! velocity w  when we compute at middle time step
426      DO jfl = 1, jpnfl
427         DO jind1 = 1, 4
428            DO jind2 = 1, 4
429               DO jind3 = 1, 4
430                  ztwfl(jfl,jind1,jind2,jind3)=   &
431                     &   ( tcoef1(ki) * wb(iidw(jfl,jind1),ijdw(jfl,jind2),ikdw(jfl,jind3))+   &
432                     &     tcoef2(ki) * wn(iidw(jfl,jind1),ijdw(jfl,jind2),ikdw(jfl,jind3)) )  &
433                     &   / e3w_n(iidw(jfl,jind1),ijdw(jfl,jind2),ikdw(jfl,jind3))
434               END DO
435            END DO
436         END DO
437         
438         zsumw = 0.e0
439         DO jind1 = 1, 4
440            DO jind2 = 1, 4
441               DO jind3 = 1, 4
442                  zsumw = zsumw + ztwfl(jfl,jind1,jind2,jind3) * zlagxw(jfl,jind1) * zlagyw(jfl,jind2)   &
443                     &  * zlagzw(jfl,jind3) * rcoef(jind1)*rcoef(jind2)*rcoef(jind3)
444               END DO
445            END DO
446         END DO
447         pwfl(jfl) = zsumw
448      END DO
449      !   
450      !   
451   END SUBROUTINE flo_interp
452
453#  else
454   !!----------------------------------------------------------------------
455   !!   No floats                                              Dummy module
456   !!----------------------------------------------------------------------
457#endif
458   
459   !!======================================================================
460END MODULE flo4rk
Note: See TracBrowser for help on using the repository browser.