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.
floblk.F90 in branches/nemo_v3_3_beta/NEMOGCM/NEMO/OPA_SRC/FLO – NEMO

source: branches/nemo_v3_3_beta/NEMOGCM/NEMO/OPA_SRC/FLO/floblk.F90 @ 2287

Last change on this file since 2287 was 2287, checked in by smasson, 14 years ago

update licence of all NEMO files...
  • Property svn:keywords set to Id
File size: 18.4 KB
Line 
1MODULE floblk
2   !!======================================================================
3   !!                     ***  MODULE  floblk  ***
4   !! Ocean floats :   trajectory computation
5   !!======================================================================
6#if   defined key_floats   ||   defined key_esopa
7   !!----------------------------------------------------------------------
8   !!   'key_floats'                                     float trajectories
9   !!----------------------------------------------------------------------
10
11   !!----------------------------------------------------------------------
12   !!    flotblk     : compute float trajectories with Blanke algorithme
13   !!----------------------------------------------------------------------
14   !! * Modules used
15   USE flo_oce         ! ocean drifting floats
16   USE oce             ! ocean dynamics and tracers
17   USE dom_oce         ! ocean space and time domain
18   USE phycst          ! physical constants
19   USE in_out_manager  ! I/O manager
20   USE lib_mpp         ! distribued memory computing library
21
22   IMPLICIT NONE
23   PRIVATE
24
25   !! * Accessibility
26   PUBLIC flo_blk      ! routine called by floats.F90
27
28   !! * Substitutions
29#  include "domzgr_substitute.h90"
30   !!----------------------------------------------------------------------
31   !! NEMO/OPA 3.3 , NEMO Consortium (2010)
32   !! $Id$
33   !! Software governed by the CeCILL licence (NEMOGCM/NEMO_CeCILL.txt)
34   !!----------------------------------------------------------------------
35
36CONTAINS
37
38   SUBROUTINE flo_blk( kt )
39      !!---------------------------------------------------------------------
40      !!                  ***  ROUTINE flo_blk  ***
41      !!           
42      !! ** Purpose :   Compute the geographical position,latitude, longitude
43      !!      and depth of each float at each time step.
44      !!
45      !! ** Method  :   The position of a float is computed with Bruno Blanke
46      !!      algorithm. We need to know the velocity field, the old positions
47      !!      of the floats and the grid defined on the domain.
48      !!
49      !!----------------------------------------------------------------------
50      !! * arguments
51      INTEGER, INTENT( in  ) ::   kt ! ocean time step
52
53      !! * Local declarations
54      INTEGER :: jfl              ! dummy loop arguments
55      INTEGER :: ind, ifin, iloop
56      INTEGER , DIMENSION ( jpnfl )  ::   &
57         iil, ijl, ikl,             &     ! index of nearest mesh
58         iiloc , ijloc,             &
59         iiinfl, ijinfl, ikinfl,    &     ! index of input mesh of the float.
60         iioutfl, ijoutfl, ikoutfl        ! index of output mesh of the float.
61      REAL(wp) , DIMENSION ( jpnfl )  ::    &
62         zgifl, zgjfl, zgkfl,       &     ! position of floats, index on
63                                          ! velocity mesh.
64         ztxfl, ztyfl, ztzfl,       &     ! time for a float to quit the mesh
65                                          ! across one of the face x,y and z
66         zttfl,                     &     ! time for a float to quit the mesh
67         zagefl,                    &     ! time during which, trajectorie of
68                                          ! the float has been computed
69         zagenewfl,                 &     ! new age of float after calculation
70                                          ! of new position
71         zufl, zvfl, zwfl,          &     ! interpolated vel. at float position
72         zudfl, zvdfl, zwdfl,       &     ! velocity diff input/output of mesh
73         zgidfl, zgjdfl, zgkdfl           ! direction index of float
74      REAL(wp)   ::       &
75         zuinfl,zvinfl,zwinfl,      &     ! transport across the input face
76         zuoutfl,zvoutfl,zwoutfl,   &     ! transport across the ouput face
77         zvol,                      &     ! volume of the mesh
78         zsurfz,                    &     ! surface of the face of the mesh
79         zind
80      REAL(wp), DIMENSION ( 2 )  ::   &
81         zsurfx, zsurfy                   ! surface of the face of the mesh
82      !!---------------------------------------------------------------------
83     
84      IF( kt == nit000 ) THEN
85         IF(lwp) WRITE(numout,*)
86         IF(lwp) WRITE(numout,*) 'flo_blk : compute Blanke trajectories for floats '
87         IF(lwp) WRITE(numout,*) '~~~~~~~ '
88      ENDIF
89
90      ! Initialisation of parameters
91     
92      DO jfl = 1, jpnfl
93         ! ages of floats are put at zero
94         zagefl(jfl) = 0.
95         ! index on the velocity grid
96         ! We considere k coordinate negative, with this transformation
97         ! the computation in the 3 direction is the same.
98         zgifl(jfl) = tpifl(jfl) - 0.5
99         zgjfl(jfl) = tpjfl(jfl) - 0.5
100         zgkfl(jfl) = MIN(-1.,-(tpkfl(jfl)))
101         ! surface drift every 10 days
102         IF( ln_argo ) THEN
103            IF( MOD(kt,150) >= 146 .OR. MOD(kt,150) == 0 )  zgkfl(jfl) = -1.
104         ENDIF
105         ! index of T mesh
106         iil(jfl) = 1 + INT(zgifl(jfl))
107         ijl(jfl) = 1 + INT(zgjfl(jfl))
108         ikl(jfl) =     INT(zgkfl(jfl))
109      END DO
110       
111      iloop = 0
112222   DO jfl = 1, jpnfl
113# if   defined key_mpp_mpi   ||   defined key_mpp_shmem
114         IF( (iil(jfl) >= (mig(nldi)-jpizoom+1)) .AND. (iil(jfl) <= (mig(nlei)-jpizoom+1)) .AND.   &
115             (ijl(jfl) >= (mjg(nldj)-jpjzoom+1)) .AND. (ijl(jfl) <= (mjg(nlej)-jpjzoom+1)) ) THEN
116            iiloc(jfl) = iil(jfl) - (mig(1)-jpizoom+1) + 1
117            ijloc(jfl) = ijl(jfl) - (mjg(1)-jpjzoom+1) + 1
118# else
119            iiloc(jfl) = iil(jfl)
120            ijloc(jfl) = ijl(jfl)
121# endif
122           
123            ! compute the transport across the mesh where the float is.           
124!!bug (gm) change e3t into fse3. but never checked
125            zsurfx(1) = e2u(iiloc(jfl)-1,ijloc(jfl)  ) * fse3u(iiloc(jfl)-1,ijloc(jfl)  ,-ikl(jfl))
126            zsurfx(2) = e2u(iiloc(jfl)  ,ijloc(jfl)  ) * fse3u(iiloc(jfl)  ,ijloc(jfl)  ,-ikl(jfl))
127            zsurfy(1) = e1v(iiloc(jfl)  ,ijloc(jfl)-1) * fse3v(iiloc(jfl)  ,ijloc(jfl)-1,-ikl(jfl))
128            zsurfy(2) = e1v(iiloc(jfl)  ,ijloc(jfl)  ) * fse3v(iiloc(jfl)  ,ijloc(jfl)  ,-ikl(jfl))
129
130            ! for a isobar float zsurfz is put to zero. The vertical velocity will be zero too.
131            zsurfz = e1t(iiloc(jfl),ijloc(jfl)) * e2t(iiloc(jfl),ijloc(jfl))
132            zvol   = zsurfz * fse3t(iiloc(jfl),ijloc(jfl),-ikl(jfl))
133
134            !
135            zuinfl =( ub(iiloc(jfl)-1,ijloc(jfl),-ikl(jfl)) + un(iiloc(jfl)-1,ijloc(jfl),-ikl(jfl)) )/2.*zsurfx(1)
136            zuoutfl=( ub(iiloc(jfl)  ,ijloc(jfl),-ikl(jfl)) + un(iiloc(jfl)  ,ijloc(jfl),-ikl(jfl)) )/2.*zsurfx(2)
137            zvinfl =( vb(iiloc(jfl),ijloc(jfl)-1,-ikl(jfl)) + vn(iiloc(jfl),ijloc(jfl)-1,-ikl(jfl)) )/2.*zsurfy(1)
138            zvoutfl=( vb(iiloc(jfl),ijloc(jfl)  ,-ikl(jfl)) + vn(iiloc(jfl),ijloc(jfl)  ,-ikl(jfl)) )/2.*zsurfy(2)
139            zwinfl =-(wb(iiloc(jfl),ijloc(jfl),-(ikl(jfl)-1))    &
140               &   +  wn(iiloc(jfl),ijloc(jfl),-(ikl(jfl)-1)) )/2. *  zsurfz*nisobfl(jfl)
141            zwoutfl=-(wb(iiloc(jfl),ijloc(jfl),- ikl(jfl)   )   &
142               &   +  wn(iiloc(jfl),ijloc(jfl),- ikl(jfl)   ) )/2. *  zsurfz*nisobfl(jfl)
143           
144            ! interpolation of velocity field on the float initial position           
145            zufl(jfl)=  zuinfl  + ( zgifl(jfl) - float(iil(jfl)-1) ) * ( zuoutfl - zuinfl)
146            zvfl(jfl)=  zvinfl  + ( zgjfl(jfl) - float(ijl(jfl)-1) ) * ( zvoutfl - zvinfl)
147            zwfl(jfl)=  zwinfl  + ( zgkfl(jfl) - float(ikl(jfl)-1) ) * ( zwoutfl - zwinfl)
148           
149            ! faces of input and output
150            ! u-direction
151            IF( zufl(jfl) < 0. ) THEN
152               iioutfl(jfl) = iil(jfl) - 1.
153               iiinfl (jfl) = iil(jfl)
154               zind   = zuinfl
155               zuinfl = zuoutfl
156               zuoutfl= zind
157            ELSE
158               iioutfl(jfl) = iil(jfl)
159               iiinfl (jfl) = iil(jfl) - 1
160            ENDIF
161            ! v-direction       
162            IF( zvfl(jfl) < 0. ) THEN
163               ijoutfl(jfl) = ijl(jfl) - 1.
164               ijinfl (jfl) = ijl(jfl)
165               zind    = zvinfl
166               zvinfl  = zvoutfl
167               zvoutfl = zind
168            ELSE
169               ijoutfl(jfl) = ijl(jfl)
170               ijinfl (jfl) = ijl(jfl) - 1.
171            ENDIF
172            ! w-direction
173            IF( zwfl(jfl) < 0. ) THEN
174               ikoutfl(jfl) = ikl(jfl) - 1.
175               ikinfl (jfl) = ikl(jfl)
176               zind    = zwinfl
177               zwinfl  = zwoutfl
178               zwoutfl = zind
179            ELSE
180               ikoutfl(jfl) = ikl(jfl)
181               ikinfl (jfl) = ikl(jfl) - 1.
182            ENDIF
183           
184            ! compute the time to go out the mesh across a face
185            ! u-direction
186            zudfl (jfl) = zuoutfl - zuinfl
187            zgidfl(jfl) = float(iioutfl(jfl) - iiinfl(jfl))
188            IF( zufl(jfl)*zuoutfl <= 0. ) THEN
189               ztxfl(jfl) = 1.E99
190            ELSE
191               IF( ABS(zudfl(jfl)) >= 1.E-5 ) THEN
192                  ztxfl(jfl)= zgidfl(jfl)/zudfl(jfl) * LOG(zuoutfl/zufl (jfl))
193               ELSE
194                  ztxfl(jfl)=(float(iioutfl(jfl))-zgifl(jfl))/zufl(jfl)
195               ENDIF
196               IF( (ABS(zgifl(jfl)-float(iiinfl (jfl))) <=  1.E-7) .OR.   &
197                   (ABS(zgifl(jfl)-float(iioutfl(jfl))) <=  1.E-7) ) THEN
198                  ztxfl(jfl)=(zgidfl(jfl))/zufl(jfl)
199               ENDIF
200            ENDIF
201            ! v-direction
202            zvdfl (jfl) = zvoutfl - zvinfl
203            zgjdfl(jfl) = float(ijoutfl(jfl)-ijinfl(jfl))
204            IF( zvfl(jfl)*zvoutfl <= 0. ) THEN
205               ztyfl(jfl) = 1.E99
206            ELSE
207               IF( ABS(zvdfl(jfl)) >= 1.E-5 ) THEN
208                  ztyfl(jfl) = zgjdfl(jfl)/zvdfl(jfl) * LOG(zvoutfl/zvfl (jfl))
209               ELSE
210                  ztyfl(jfl) = (float(ijoutfl(jfl)) - zgjfl(jfl))/zvfl(jfl)
211               ENDIF
212               IF( (ABS(zgjfl(jfl)-float(ijinfl (jfl))) <= 1.E-7) .OR.   &
213                   (ABS(zgjfl(jfl)-float(ijoutfl(jfl))) <=  1.E-7) ) THEN
214                  ztyfl(jfl) = (zgjdfl(jfl)) / zvfl(jfl)
215               ENDIF
216            ENDIF
217            ! w-direction       
218            IF( nisobfl(jfl) == 1. ) THEN
219               zwdfl (jfl) = zwoutfl - zwinfl
220               zgkdfl(jfl) = float(ikoutfl(jfl) - ikinfl(jfl))
221               IF( zwfl(jfl)*zwoutfl <= 0. ) THEN
222                  ztzfl(jfl) = 1.E99
223               ELSE
224                  IF( ABS(zwdfl(jfl)) >= 1.E-5 ) THEN
225                     ztzfl(jfl) = zgkdfl(jfl)/zwdfl(jfl) * LOG(zwoutfl/zwfl (jfl))
226                  ELSE
227                     ztzfl(jfl) = (float(ikoutfl(jfl)) - zgkfl(jfl))/zwfl(jfl)
228                  ENDIF
229                  IF( (ABS(zgkfl(jfl)-float(ikinfl (jfl))) <=  1.E-7) .OR.   &
230                      (ABS(zgkfl(jfl)-float(ikoutfl(jfl))) <= 1.E-7) ) THEN
231                     ztzfl(jfl) = (zgkdfl(jfl)) / zwfl(jfl)
232                  ENDIF
233               ENDIF
234            ENDIF
235           
236            ! the time to go leave the mesh is the smallest time
237                   
238            IF( nisobfl(jfl) == 1. ) THEN
239               zttfl(jfl) = MIN(ztxfl(jfl),ztyfl(jfl),ztzfl(jfl))
240            ELSE
241               zttfl(jfl) = MIN(ztxfl(jfl),ztyfl(jfl))
242            ENDIF
243            ! new age of the FLOAT
244            zagenewfl(jfl) = zagefl(jfl) + zttfl(jfl)*zvol
245            ! test to know if the "age" of the float is not bigger than the
246            ! time step
247            IF( zagenewfl(jfl) > rdt ) THEN
248               zttfl(jfl) = (rdt-zagefl(jfl)) / zvol
249               zagenewfl(jfl) = rdt
250            ENDIF
251           
252            ! In the "minimal" direction we compute the index of new mesh
253            ! on i-direction
254            IF( ztxfl(jfl) <=  zttfl(jfl) ) THEN
255               zgifl(jfl) = float(iioutfl(jfl))
256               ind = iioutfl(jfl)
257               IF( iioutfl(jfl) >= iiinfl(jfl) ) THEN
258                  iioutfl(jfl) = iioutfl(jfl) + 1
259               ELSE
260                  iioutfl(jfl) = iioutfl(jfl) - 1
261               ENDIF
262               iiinfl(jfl) = ind
263            ELSE
264               IF( ABS(zudfl(jfl)) >= 1.E-5 ) THEN
265                  zgifl(jfl) = zgifl(jfl) + zgidfl(jfl)*zufl(jfl)    &
266                     &       * ( EXP( zudfl(jfl)/zgidfl(jfl)*zttfl(jfl) ) - 1. ) /  zudfl(jfl)
267               ELSE
268                  zgifl(jfl) = zgifl(jfl) + zufl(jfl) * zttfl(jfl)
269               ENDIF
270            ENDIF
271            ! on j-direction
272            IF( ztyfl(jfl) <= zttfl(jfl) ) THEN
273               zgjfl(jfl) = float(ijoutfl(jfl))
274               ind = ijoutfl(jfl)
275               IF( ijoutfl(jfl) >= ijinfl(jfl) ) THEN
276                  ijoutfl(jfl) = ijoutfl(jfl) + 1
277               ELSE
278                  ijoutfl(jfl) = ijoutfl(jfl) - 1
279               ENDIF
280               ijinfl(jfl) = ind
281            ELSE
282               IF( ABS(zvdfl(jfl)) >= 1.E-5 ) THEN
283                  zgjfl(jfl) = zgjfl(jfl)+zgjdfl(jfl)*zvfl(jfl)   &
284                     &       * ( EXP(zvdfl(jfl)/zgjdfl(jfl)*zttfl(jfl)) - 1. ) /  zvdfl(jfl)
285               ELSE
286                  zgjfl(jfl) = zgjfl(jfl)+zvfl(jfl)*zttfl(jfl)
287               ENDIF
288            ENDIF
289            ! on k-direction
290            IF( nisobfl(jfl) == 1. ) THEN
291               IF( ztzfl(jfl) <= zttfl(jfl) ) THEN
292                  zgkfl(jfl) = float(ikoutfl(jfl))
293                  ind = ikoutfl(jfl)
294                  IF( ikoutfl(jfl) >= ikinfl(jfl) ) THEN
295                     ikoutfl(jfl) = ikoutfl(jfl)+1
296                  ELSE
297                     ikoutfl(jfl) = ikoutfl(jfl)-1
298                  ENDIF
299                  ikinfl(jfl) = ind
300               ELSE
301                  IF( ABS(zwdfl(jfl)) >= 1.E-5 ) THEN
302                     zgkfl(jfl) = zgkfl(jfl)+zgkdfl(jfl)*zwfl(jfl)    &
303                        &       * ( EXP(zwdfl(jfl)/zgkdfl(jfl)*zttfl(jfl)) - 1. ) /  zwdfl(jfl)
304                  ELSE
305                     zgkfl(jfl) = zgkfl(jfl)+zwfl(jfl)*zttfl(jfl)
306                  ENDIF
307               ENDIF
308            ENDIF
309           
310            ! coordinate of the new point on the temperature grid
311           
312            iil(jfl) = MAX(iiinfl(jfl),iioutfl(jfl))
313            ijl(jfl) = MAX(ijinfl(jfl),ijoutfl(jfl))
314            IF( nisobfl(jfl) ==  1 ) ikl(jfl) = MAX(ikinfl(jfl),ikoutfl(jfl))
315!!Alexcadm   write(*,*)'PE ',narea,
316!!Alexcadm     .    iiinfl(jfl),iioutfl(jfl),ijinfl(jfl)
317!!Alexcadm     .     ,ijoutfl(jfl),ikinfl(jfl),
318!!Alexcadm     .    ikoutfl(jfl),ztxfl(jfl),ztyfl(jfl)
319!!Alexcadm     .     ,ztzfl(jfl),zgifl(jfl),
320!!Alexcadm     .  zgjfl(jfl)
321!!Alexcadm  IF (jfl == 910) write(*,*)'Flotteur 910',
322!!Alexcadm     .    iiinfl(jfl),iioutfl(jfl),ijinfl(jfl)
323!!Alexcadm     .     ,ijoutfl(jfl),ikinfl(jfl),
324!!Alexcadm     .    ikoutfl(jfl),ztxfl(jfl),ztyfl(jfl)
325!!Alexcadm     .     ,ztzfl(jfl),zgifl(jfl),
326!!Alexcadm     .  zgjfl(jfl)
327            ! reinitialisation of the age of FLOAT
328            zagefl(jfl) = zagenewfl(jfl)
329# if   defined key_mpp_mpi   ||   defined key_mpp_shmem
330         ELSE
331            ! we put zgifl, zgjfl, zgkfl, zagefl
332            zgifl (jfl) = 0.
333            zgjfl (jfl) = 0.
334            zgkfl (jfl) = 0.
335            zagefl(jfl) = 0.
336            iil(jfl) = 0
337            ijl(jfl) = 0
338         ENDIF
339# endif
340      END DO
341     
342      ! synchronisation
343      IF( lk_mpp )   CALL mpp_sum( zgifl , jpnfl )   ! sums over the global domain
344      IF( lk_mpp )   CALL mpp_sum( zgjfl , jpnfl )
345      IF( lk_mpp )   CALL mpp_sum( zgkfl , jpnfl )
346      IF( lk_mpp )   CALL mpp_sum( zagefl, jpnfl )
347      IF( lk_mpp )   CALL mpp_sum( iil   , jpnfl )
348      IF( lk_mpp )   CALL mpp_sum( ijl   , jpnfl )
349     
350      ! in the case of open boundaries we need to test if the floats don't
351      ! go out of the domain. If it goes out, the float is put at the
352      ! middle of the mesh in the domain but the trajectory isn't compute
353      ! more time.     
354# if defined key_obc
355      DO jfl = 1, jpnfl
356         IF( lp_obc_east ) THEN
357            IF( jped <=  zgjfl(jfl) .AND. zgjfl(jfl) <= jpef .AND. nieob-1 <=  zgifl(jfl) ) THEN
358               zgifl (jfl) = INT(zgifl(jfl)) + 0.5
359               zgjfl (jfl) = INT(zgjfl(jfl)) + 0.5
360               zagefl(jfl) = rdt
361            END IF
362         END IF
363         IF( lp_obc_west ) THEN
364            IF( jpwd <= zgjfl(jfl) .AND. zgjfl(jfl) <= jpwf .AND. niwob >=  zgifl(jfl) ) THEN
365               zgifl (jfl) = INT(zgifl(jfl)) + 0.5
366               zgjfl (jfl) = INT(zgjfl(jfl)) + 0.5
367               zagefl(jfl) = rdt
368            END IF
369         END IF
370         IF( lp_obc_north ) THEN
371            IF( jpnd <=  zgifl(jfl) .AND. zgifl(jfl) <= jpnf .AND. njnob-1 >=  zgjfl(jfl) ) THEN
372               zgifl (jfl) = INT(zgifl(jfl)) + 0.5
373               zgjfl (jfl) = INT(zgjfl(jfl)) + 0.5
374               zagefl(jfl) = rdt
375            END IF
376         END IF
377         IF( lp_obc_south ) THEN
378            IF( jpsd <=  zgifl(jfl) .AND. zgifl(jfl) <= jpsf .AND.  njsob >= zgjfl(jfl) ) THEN
379               zgifl (jfl) = INT(zgifl(jfl)) + 0.5
380               zgjfl (jfl) = INT(zgjfl(jfl)) + 0.5
381               zagefl(jfl) = rdt
382            END IF
383         END IF
384      END DO
385#endif
386
387      ! Test to know if a  float hasn't integrated enought time
388      IF( ln_argo ) THEN
389         ifin = 1
390         DO jfl = 1, jpnfl
391            IF( zagefl(jfl) < rdt )   ifin = 0
392            tpifl(jfl) = zgifl(jfl) + 0.5
393            tpjfl(jfl) = zgjfl(jfl) + 0.5
394         END DO
395      ELSE
396         ifin = 1
397         DO jfl = 1, jpnfl
398            IF( zagefl(jfl) < rdt )   ifin = 0
399            tpifl(jfl) = zgifl(jfl) + 0.5
400            tpjfl(jfl) = zgjfl(jfl) + 0.5
401            IF( nisobfl(jfl) == 1 ) tpkfl(jfl) = -(zgkfl(jfl))
402         END DO
403      ENDIF
404!!Alexcadm  IF (lwp) write(numout,*) '---------'
405!!Alexcadm  IF (lwp) write(numout,*) 'before Erika:',tpifl(880),tpjfl(880),
406!!Alexcadm     .       tpkfl(880),zufl(880),zvfl(880),zwfl(880)
407!!Alexcadm  IF (lwp) write(numout,*) 'first Erika:',tpifl(900),tpjfl(900),
408!!Alexcadm     .       tpkfl(900),zufl(900),zvfl(900),zwfl(900)
409!!Alexcadm  IF (lwp) write(numout,*) 'last Erika:',tpifl(jpnfl),tpjfl(jpnfl),
410!!Alexcadm     .       tpkfl(jpnfl),zufl(jpnfl),zvfl(jpnfl),zwfl(jpnfl)
411      IF( ifin == 0 ) THEN
412         iloop = iloop + 1 
413         GO TO 222
414      ENDIF
415
416   END SUBROUTINE flo_blk
417
418#  else
419   !!----------------------------------------------------------------------
420   !!   Default option                                         Empty module
421   !!----------------------------------------------------------------------
422CONTAINS
423   SUBROUTINE flo_blk                  ! Empty routine
424   END SUBROUTINE flo_blk 
425#endif
426   
427   !!======================================================================
428END MODULE floblk 
Note: See TracBrowser for help on using the repository browser.