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 branches/2011/DEV_r2739_STFC_dCSE/NEMOGCM/NEMO/OPA_SRC/FLO – NEMO

source: branches/2011/DEV_r2739_STFC_dCSE/NEMOGCM/NEMO/OPA_SRC/FLO/flo4rk.F90 @ 4460

Last change on this file since 4460 was 3211, checked in by spickles2, 13 years ago

Stephen Pickles, 11 Dec 2011

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