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/2019/dev_r10721_KERNEL-02_Storkey_Coward_IMMERSE_first_steps/src/OCE/FLO – NEMO

source: NEMO/branches/2019/dev_r10721_KERNEL-02_Storkey_Coward_IMMERSE_first_steps/src/OCE/FLO/flo4rk.F90 @ 10970

Last change on this file since 10970 was 10970, checked in by davestorkey, 5 years ago

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