File: /nfs/home/0/users/jenkins/mfix.git/model/functions_mod.f

1     MODULE functions
2     
3       !^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^C
4       !
5       !                      Function for generating the LOCAL 3-D array index IJK
6       !                      from the 1-D indices I, J, and K.
7       !//FUNIJK is moved to compar for debugging purposes - Sreekanth-10/26/99
8       !      INTEGER          FUNIJK,FUNIJK_0
9       !      INTEGER          FUNIJK_0
10       !                      Function for generating the LOCAL 3-D array index IJK
11       !                      from the 1-D indices I, J, K and IPROC.
12       !      INTEGER          FUNIJK_PROC
13       !                      Function for generating the GLOBAL 3-D array index IJK
14       !                      from the 1-D indices I, J, and K.
15       !      INTEGER          FUNIJK_GL
16       !
17       !                      Function for generating the index for the entries
18       !                      to the upper triangle (excluding the diagonal) of
19       !                      an (L,M) matrix.
20       !      INTEGER          FUNLM
21       !
22       !                      Function for generating the 3-D array index IJK
23       !                      from the 1-D indices I, J, and K in IO format
24       !      INTEGER          FUNIJK_IO
25       !
26       !                      Dummy arguments
27       !      DOUBLE PRECISION XXX, YYY, XXX1, XXX2, XXX3, XXX4, XXX5
28       !
29       !                      Dummy index for L and M
30       !      INTEGER          L1, L2
31     
32       !                      Dummy indices for I, J, K
33       !      INTEGER          LI, LJ, LK
34       !                      Dummy indices for IPROC
35       !      INTEGER          LIPROC
36       !
37       !                      Function for calculating IJKW
38       !      INTEGER          WEST_OF, WEST_OF_0
39       !
40       !                      Function for calculating IJKE
41       !      INTEGER          EAST_OF, EAST_OF_0
42       !
43       !                      Function for calculating IJKS
44       !      INTEGER          SOUTH_OF, SOUTH_OF_0
45       !
46       !                      Function for calculating IJKN
47       !      INTEGER          NORTH_OF, NORTH_OF_0
48       !
49       !                      Function for calculating IJKB
50       !      INTEGER          BOTTOM_OF, BOTTOM_OF_0
51       !
52       !                      Function for calculating IJKT
53       !      INTEGER          TOP_OF, TOP_OF_0
54       !
55       !                      Function for calculating IMJK
56       !      INTEGER          IM_OF, IM_OF_0
57       !
58       !                      Function for calculating IPJK
59       !      INTEGER          IP_OF, IP_OF_0
60       !
61       !                      Function for calculating IJMK
62       !      INTEGER          JM_OF, JM_OF_0
63       !
64       !                      Function for calculating IJPK
65       !      INTEGER          JP_OF, JP_OF_0
66       !
67       !                      Function for calculating IJKM
68       !      INTEGER          KM_OF, KM_OF_0
69       !
70       !                      Function for calculating IJKP
71       !      INTEGER          KP_OF, KP_OF_0
72       !
73       !                      Logical function to identify a fluid cell
74       !      LOGICAL          FLUID_AT
75       !
76       !                      cyclic condition at east boundary
77       !      LOGICAL          CYCLIC_AT_E
78       !
79       !                      cyclic condition at north boundary
80       !      LOGICAL          CYCLIC_AT_N
81       !
82       !                      cyclic condition at top boundary
83       !      LOGICAL          CYCLIC_AT_T
84       !
85       !                      identify flow at east boundary
86       !      LOGICAL          FLOW_AT_E
87       !
88       !                      identify flow at north boundary
89       !      LOGICAL          FLOW_AT_N
90       !
91       !                      identify flow at top boundary
92       !      LOGICAL          FLOW_AT_T
93       !
94       !                      identify const. pressure flow east boundary
95       !      LOGICAL          PFLOW_AT_E
96       !
97       !                      identify const. pressure flow north boundary
98       !      LOGICAL          PFLOW_AT_N
99       !
100       !                      identify const. pressure flow top boundary
101       !      LOGICAL          PFLOW_AT_T
102       !
103       !                      identify specified flow east boundary
104       !      LOGICAL          MFLOW_AT_E
105       !
106       !                      identify specified flow north boundary
107       !      LOGICAL          MFLOW_AT_N
108       !
109       !                      identify specified flow top boundary
110       !      LOGICAL          MFLOW_AT_T
111       !
112       !                      FLUID_AT or P_FLOW_AT (simplified check)
113       !      LOGICAL          FLUIDorP_FLOW_AT
114       !
115       !                      P_FLOW_AT
116       !      LOGICAL          P_FLOW_AT
117       !
118       !                      P_OUTFLOW_AT
119       !      LOGICAL          P_OUTFLOW_AT
120       !
121       !                      MASS_OUTFLOW_AT
122       !      LOGICAL          MASS_OUTFLOW_AT
123       !
124       !                      OUTFLOW_AT
125       !      LOGICAL          OUTFLOW_AT
126       !
127       !                      FLOW_AT
128       !      LOGICAL          FLOW_AT
129       !
130       !                      Logical function to identify default walls
131       !      LOGICAL          DEFAULT_WALL_AT
132       !
133       !                      Logical function to identify wall ICBC_FLAG
134       !      LOGICAL          WALL_ICBC_FLAG
135       !
136       !                      Logical function to identify a No-slip wall cell
137       !      LOGICAL          NS_WALL_AT
138       !
139       !                      Logical function to identify a Free-slip wall cell
140       !      LOGICAL          FS_WALL_AT
141       !
142       !                      Logical function to identify a Partial-slip wall cell
143       !      LOGICAL          PS_WALL_AT
144       !
145       !                      Logical function to identify a wall cell
146       !      LOGICAL          WALL_AT
147       !
148       !                      Logical function to identify a cyclic cell
149       !      LOGICAL          CYCLIC_AT
150       !
151       !                      Logical function to identify IP at East of the cell
152       !      LOGICAL          IP_AT_E
153       !
154       !                      Logical function to identify IP at North of the cell
155       !      LOGICAL          IP_AT_N
156       !
157       !                      Logical function to identify IP at Top of the cell
158       !      LOGICAL          IP_AT_T
159       !
160       !                      Logical function to identify IP or SP at East of the cell
161       !      LOGICAL          SIP_AT_E
162       !
163       !                      Logical function to identify IP or SP at North of the cell
164       !      LOGICAL          SIP_AT_N
165       !
166       !                      Logical function to identify IP or SP at Top of the cell
167       !      LOGICAL          SIP_AT_T
168       !
169       !                      Logical function to identify SP at East of the cell
170       !      LOGICAL          SP_AT_E
171       !
172       !                      Logical function to identify SP at North of the cell
173       !      LOGICAL          SP_AT_N
174       !
175       !                      Logical function to identify SP at Top of the cell
176       !      LOGICAL          SP_AT_T
177       !
178       !                      Internal surface ID for east face
179       !      INTEGER          IS_ID_AT_E
180       !
181       !                      Internal surface ID for north face
182       !      INTEGER          IS_ID_AT_N
183       !
184       !                      Internal surface ID for top face
185       !      INTEGER          IS_ID_AT_T
186       !
187       !                      Logical function to identify IS at East of the cell
188       !      LOGICAL          IS_AT_E
189       !
190       !                      Logical function to identify IS at North of the cell
191       !      LOGICAL          IS_AT_N
192       !
193       !                      Logical function to identify IS at Top of the cell
194       !      LOGICAL          IS_AT_T
195       !
196       !                      Logical function to identify No IS at East of the cell
197       !      LOGICAL          NO_IS_AT_E
198       !
199       !                      Logical function to identify No IS at North of the cell
200       !      LOGICAL          NO_IS_AT_N
201       !
202       !                      Logical function to identify No IS at Top of the cell
203       !      LOGICAL          NO_IS_AT_T
204     
205       !\\   Added to determine whether I am on my PE
206       !\\   Logical function to determine whether I am on my PE's domain
207       !      LOGICAL          IS_ON_myPE_owns
208       !\\   Logical function to determine whether I am on my PE's domain + one &
209       !                                                       extra ghost layer
210       !      LOGICAL          IS_ON_myPE_plus1layer
211       !\\   Logical function to determine whether I am on my PE's domain + two &
212       !                                                       extra ghost layers
213       !      LOGICAL          IS_ON_myPE_plus2layers
214       !\\   Logical function to determine whether I am on my PE's domain - Boundaries
215       !      LOGICAL          IS_ON_myPE_wobnd
216       !
217       !                      Maximum of zero or input
218       !      DOUBLE PRECISION ZMAX
219       !
220       !
221     CONTAINS
222     
223       !//FUNIJK is moved to compar for debugging purposes - Sreekanth-10/26/99
224       !     FUNIJK (LI, LJ, LK) = c0 + LI + (LJ-jstart3_all(myPE))*c1 + (LK-kstart3_all(myPE))* c2
225       !      funijk(li,lj,lk) = lj + c0 + li*c1 + lk*c2
226       INTEGER FUNCTION funijk_0(li,lj,lk)
227         USE compar
228         IMPLICIT NONE
229         INTEGER, INTENT(IN) :: LI, LJ, LK
230         funijk_0 = lj + c0 + li*c1 + lk*c2
231       END FUNCTION funijk_0
232     
233       INTEGER FUNCTION funijk(li,lj,lk)
234         USE compar
235         IMPLICIT NONE
236         INTEGER, INTENT(IN) :: LI, LJ, LK
237         funijk = IJK_ARRAY_OF(li,lj,lk)
238       END FUNCTION funijk
239     
240       !//SP
241       !     FUNIJK_PROC(LI, LJ, LK, LIPROC) = 1 + (LI - istart3_all(LIPROC))+ &
242       !     (LJ-jstart3_all(LIPROC))*(iend3_all(LIPROC)-istart3_all(LIPROC)+1) &
243       !     + (LK-kstart3_all(LIPROC))*(jend3_all(LIPROC)-jstart3_all(LIPROC)+1)* &
244       !     (iend3_all(LIPROC)-istart3_all(LIPROC)+1)
245     
246       INTEGER FUNCTION FUNIJK_PROC(LI, LJ, LK, LIPROC)
247         USE compar
248         IMPLICIT NONE
249         INTEGER, INTENT(IN) :: LI, LJ, LK, LIPROC
250         FUNIJK_PROC = 1 + (LJ - jstart3_all(LIPROC))+ &
251              (LI-Istart3_all(LIPROC))*(jend3_all(LIPROC)-jstart3_all(LIPROC)+1) &
252              + (LK-kstart3_all(LIPROC))*(jend3_all(LIPROC)-jstart3_all(LIPROC)+1)* &
253              (iend3_all(LIPROC)-istart3_all(LIPROC)+1)
254       END FUNCTION FUNIJK_PROC
255     
256       !     FUNIJK_GL (LI, LJ, LK) = 1 + (LI - imin3) + (LJ-jmin3)*(imax3-imin3+1) &
257       !     + (LK-kmin3)*(jmax3-jmin3+1)*(imax3-imin3+1)
258       !
259       INTEGER FUNCTION FUNIJK_GL (LI, LJ, LK)
260         USE geometry
261         IMPLICIT NONE
262         INTEGER, INTENT(IN) :: LI, LJ, LK
263         FUNIJK_GL = 1 + (LJ - jmin3) + (LI-imin3)*(jmax3-jmin3+1) &
264              + (LK-kmin3)*(jmax3-jmin3+1)*(imax3-imin3+1)
265       END FUNCTION FUNIJK_GL
266     
267       INTEGER FUNCTION FUNIJK_IO (LI, LJ, LK)
268         USE geometry
269         IMPLICIT NONE
270         INTEGER, INTENT(IN) :: LI, LJ, LK
271         FUNIJK_IO = 1 + (LI - imin2) + (LJ-jmin2)*(imax2-imin2+1) &
272              + (LK-kmin2)*(jmax2-jmin2+1)*(imax2-imin2+1)
273       END FUNCTION FUNIJK_IO
274     
275     
276     
277     !----------------------------------------------------------------------!
278     !  Function: IS_ON_myPE_OWNS                                           !
279     !                                                                      !
280     !  Purpose: Returns TRUE if the I,J,K values point to a computational  !
281     !  cell that is OWNED by the current process.                          !
282     !                                                                      !
283     !  o Ownership is defined as belonging to the current PE's domain but  !
284     !    as a cell in any of the PE's ghost layers.                        !
285     !                                                                      !
286     !  o Each computational cell is owned by one -and only one- PE.        !
287     !----------------------------------------------------------------------!
288           LOGICAL FUNCTION IS_ON_myPE_OWNS(LI, LJ, LK)
289             USE compar
290             IMPLICIT NONE
291     
292             INTEGER, INTENT(IN) :: LI, LJ, LK
293     
294           IS_ON_MYPE_OWNS = &
295              LI >= ISTART .AND. LI <= IEND .AND. &
296              LJ >= JSTART .AND. LJ <= JEND .AND. &
297              LK >= KSTART .AND. LK <= KEND
298     
299           RETURN
300           END FUNCTION IS_ON_MYPE_OWNS
301     
302     
303     !----------------------------------------------------------------------!
304     !  Function: IS_ON_myPE_WOBND                                          !
305     !                                                                      !
306     !  Purpose: Returns TRUE if the I,J,K values point to a computational  !
307     !  cell that is OWNED by the current process and not a exterior ghost  !
308     !  cell.                                                               !
309     !                                                                      !
310     !  o This is a subset of IS_ON_myPE_OWNS.                              !
311     !                                                                      !
312     !  o Exterior ghost cells are those in cells surrounding the domain.   !
313     !    These are cells created to fully define boundary conditions       !
314     !    (e.g., I == 1 where X_E(1) == ZERO).                              !
315     !                                                                      !
316     !----------------------------------------------------------------------!
317           LOGICAL FUNCTION IS_ON_myPE_wobnd (LI, LJ, LK)
318             USE compar
319             IMPLICIT NONE
320     
321             INTEGER, INTENT(IN) :: LI, LJ, LK
322     
323           IS_ON_MYPE_WOBND = &
324              LI >= ISTART1 .AND. LI <= IEND1 .AND. &
325              LJ >= JSTART1 .AND. LJ <= JEND1 .AND. &
326              LK >= KSTART1 .AND. LK <= KEND1
327     
328           RETURN
329           END FUNCTION IS_ON_myPE_wobnd
330     
331     !----------------------------------------------------------------------!
332     !  Function: IS_ON_myPE_Plus1Layer                                     !
333     !                                                                      !
334     !  Purpose: Returns TRUE if the I,J,K values point to a computational  !
335     !  cell that is OWNED by the current process or contained in the fisrt !
336     !  layer of ghost cells seen by the current PE.                        !
337     !                                                                      !
338     !  o This is a superset of IS_ON_myPE_OWNS.                            !
339     !                                                                      !
340     !----------------------------------------------------------------------!
341           LOGICAL FUNCTION IS_ON_myPE_plus1layer (LI, LJ, LK)
342             USE compar
343             IMPLICIT NONE
344     
345             INTEGER, INTENT(IN) :: LI, LJ, LK
346     
347           IS_ON_MYPE_PLUS1LAYER = &
348              LI >= ISTART2 .AND. LI <= IEND2 .AND. &
349              LJ >= JSTART2 .AND. LJ <= JEND2 .AND. &
350              LK >= KSTART2 .AND. LK <= KEND2
351     
352           RETURN
353           END FUNCTION IS_ON_myPE_plus1layer
354     
355     
356     !----------------------------------------------------------------------!
357     !  Function: IS_ON_myPE_Plus2Layer                                     !
358     !                                                                      !
359     !  Purpose: Returns TRUE if the I,J,K values point to a computational  !
360     !  cell that is OWNED by the current process or contained in the fisrt !
361     !  two layers of ghost cells seen by the current PE.                   !
362     !                                                                      !
363     !  o This is a superset of IS_ON_Plus1Layer.                           !
364     !                                                                      !
365     !----------------------------------------------------------------------!
366           LOGICAL FUNCTION IS_ON_myPE_plus2layers (LI, LJ, LK)
367             USE compar
368             IMPLICIT NONE
369     
370             INTEGER, INTENT(IN) :: LI, LJ, LK
371     
372           IS_ON_MYPE_PLUS2LAYERS = &
373              LI >= ISTART3 .AND. LI <= IEND3 .AND. &
374              LJ >= JSTART3 .AND. LJ <= JEND3 .AND. &
375              LK >= KSTART3 .AND. LK <= KEND3
376     
377           RETURN
378           END FUNCTION IS_ON_myPE_plus2layers
379     
380     
381     
382       !      WEST_OF  (IJK)   = IJK + INCREMENT_FOR_w (CELL_CLASS(IJK))
383       !      EAST_OF  (IJK)   = IJK + INCREMENT_FOR_e (CELL_CLASS(IJK))
384       !      SOUTH_OF (IJK)   = IJK + INCREMENT_FOR_s (CELL_CLASS(IJK))
385       !      NORTH_OF (IJK)   = IJK + INCREMENT_FOR_n (CELL_CLASS(IJK))
386       !      BOTTOM_OF(IJK)   = IJK + INCREMENT_FOR_b (CELL_CLASS(IJK))
387       !      TOP_OF   (IJK)   = IJK + INCREMENT_FOR_t (CELL_CLASS(IJK))
388       !      IM_OF  (IJK)     = IJK + INCREMENT_FOR_im(CELL_CLASS(IJK))
389       !      IP_OF  (IJK)     = IJK + INCREMENT_FOR_ip(CELL_CLASS(IJK))
390       !      JM_OF (IJK)      = IJK + INCREMENT_FOR_jm(CELL_CLASS(IJK))
391       !      JP_OF (IJK)      = IJK + INCREMENT_FOR_jp(CELL_CLASS(IJK))
392       !      KM_OF(IJK)       = IJK + INCREMENT_FOR_km(CELL_CLASS(IJK))
393       !      KP_OF   (IJK)    = IJK + INCREMENT_FOR_kp(CELL_CLASS(IJK))
394     
395       INTEGER FUNCTION EAST_OF  (IJK)
396         USE indices
397         IMPLICIT NONE
398         INTEGER IJK
399     
400         EAST_OF = IJK + INCREMENT_FOR_NB (1,CELL_CLASS(IJK))
401       END FUNCTION EAST_OF
402     
403       INTEGER FUNCTION WEST_OF  (IJK)
404         USE indices
405         IMPLICIT NONE
406         INTEGER IJK
407         WEST_OF = IJK + INCREMENT_FOR_NB (2,CELL_CLASS(IJK))
408       END FUNCTION WEST_OF
409     
410       INTEGER FUNCTION SOUTH_OF (IJK)
411         USE indices
412         IMPLICIT NONE
413         INTEGER IJK
414         SOUTH_OF = IJK + INCREMENT_FOR_NB (3,CELL_CLASS(IJK))
415       END FUNCTION SOUTH_OF
416     
417       INTEGER FUNCTION NORTH_OF (IJK)
418         USE indices
419         IMPLICIT NONE
420         INTEGER IJK
421         NORTH_OF = IJK + INCREMENT_FOR_NB (4,CELL_CLASS(IJK))
422       END FUNCTION NORTH_OF
423     
424       INTEGER FUNCTION BOTTOM_OF(IJK)
425         USE indices
426         IMPLICIT NONE
427         INTEGER IJK
428         BOTTOM_OF = IJK + INCREMENT_FOR_NB (5,CELL_CLASS(IJK))
429       END FUNCTION BOTTOM_OF
430     
431       INTEGER FUNCTION TOP_OF   (IJK)
432         USE indices
433         IMPLICIT NONE
434         INTEGER IJK
435         TOP_OF = IJK + INCREMENT_FOR_NB (6,CELL_CLASS(IJK))
436       END FUNCTION TOP_OF
437     
438     
439       INTEGER FUNCTION IM_OF  (IJK)
440         USE indices
441         IMPLICIT NONE
442         INTEGER IJK
443         IM_OF = IJK + INCREMENT_FOR_MP(1,CELL_CLASS(IJK))
444       END FUNCTION IM_OF
445     
446       INTEGER FUNCTION IP_OF  (IJK)
447         USE indices
448         IMPLICIT NONE
449         INTEGER IJK
450         IP_OF = IJK + INCREMENT_FOR_MP(2,CELL_CLASS(IJK))
451       END FUNCTION IP_OF
452     
453       INTEGER FUNCTION JM_OF (IJK)
454         USE indices
455         IMPLICIT NONE
456         INTEGER IJK
457         JM_OF = IJK + INCREMENT_FOR_MP(3,CELL_CLASS(IJK))
458       END FUNCTION JM_OF
459     
460       INTEGER FUNCTION JP_OF (IJK)
461         USE indices
462         IMPLICIT NONE
463         INTEGER IJK
464         JP_OF = IJK + INCREMENT_FOR_MP(4,CELL_CLASS(IJK))
465       END FUNCTION JP_OF
466     
467       INTEGER FUNCTION KM_OF(IJK)
468         USE indices
469         IMPLICIT NONE
470         INTEGER IJK
471         KM_OF = IJK + INCREMENT_FOR_MP(5,CELL_CLASS(IJK))
472       END FUNCTION KM_OF
473     
474       INTEGER FUNCTION KP_OF   (IJK)
475         USE indices
476         IMPLICIT NONE
477         INTEGER IJK
478         KP_OF = IJK + INCREMENT_FOR_MP(6,CELL_CLASS(IJK))
479       END FUNCTION KP_OF
480     
481       INTEGER FUNCTION WEST_OF_0  (IJK)
482         USE indices
483         IMPLICIT NONE
484         INTEGER IJK
485         WEST_OF_0 = IJK + INCREMENT_FOR_w (CELL_CLASS(IJK))
486       END FUNCTION WEST_OF_0
487     
488       INTEGER FUNCTION EAST_OF_0  (IJK)
489         USE indices
490         IMPLICIT NONE
491         INTEGER IJK
492         EAST_OF_0 = IJK + INCREMENT_FOR_e (CELL_CLASS(IJK))
493       END FUNCTION EAST_OF_0
494     
495       INTEGER FUNCTION SOUTH_OF_0 (IJK)
496         USE indices
497         IMPLICIT NONE
498         INTEGER IJK
499         SOUTH_OF_0 = IJK + INCREMENT_FOR_s (CELL_CLASS(IJK))
500       END FUNCTION SOUTH_OF_0
501     
502       INTEGER FUNCTION NORTH_OF_0 (IJK)
503         USE indices
504         IMPLICIT NONE
505         INTEGER IJK
506         NORTH_OF_0 = IJK + INCREMENT_FOR_n (CELL_CLASS(IJK))
507       END FUNCTION NORTH_OF_0
508     
509       INTEGER FUNCTION BOTTOM_OF_0(IJK)
510         USE indices
511         IMPLICIT NONE
512         INTEGER IJK
513         BOTTOM_OF_0 = IJK + INCREMENT_FOR_b (CELL_CLASS(IJK))
514       END FUNCTION BOTTOM_OF_0
515     
516       INTEGER FUNCTION TOP_OF_0   (IJK)
517         USE indices
518         IMPLICIT NONE
519         INTEGER IJK
520         TOP_OF_0 = IJK + INCREMENT_FOR_t (CELL_CLASS(IJK))
521       END FUNCTION TOP_OF_0
522     
523       INTEGER FUNCTION IM_OF_0  (IJK)
524         USE indices
525         IMPLICIT NONE
526         INTEGER IJK
527         IM_OF_0 = IJK + INCREMENT_FOR_im(CELL_CLASS(IJK))
528       END FUNCTION IM_OF_0
529     
530       INTEGER FUNCTION IP_OF_0  (IJK)
531         USE indices
532         IMPLICIT NONE
533         INTEGER IJK
534         IP_OF_0 = IJK + INCREMENT_FOR_ip(CELL_CLASS(IJK))
535       END FUNCTION IP_OF_0
536     
537       INTEGER FUNCTION JM_OF_0 (IJK)
538         USE indices
539         IMPLICIT NONE
540         INTEGER IJK
541         JM_OF_0 = IJK + INCREMENT_FOR_jm(CELL_CLASS(IJK))
542       END FUNCTION JM_OF_0
543     
544       INTEGER FUNCTION JP_OF_0 (IJK)
545         USE indices
546         IMPLICIT NONE
547         INTEGER IJK
548         JP_OF_0 = IJK + INCREMENT_FOR_jp(CELL_CLASS(IJK))
549       END FUNCTION JP_OF_0
550     
551       INTEGER FUNCTION KM_OF_0(IJK)
552         USE indices
553         IMPLICIT NONE
554         INTEGER IJK
555         KM_OF_0 = IJK + INCREMENT_FOR_km(CELL_CLASS(IJK))
556       END FUNCTION KM_OF_0
557     
558       INTEGER FUNCTION KP_OF_0   (IJK)
559         USE indices
560         IMPLICIT NONE
561         INTEGER IJK
562         KP_OF_0 = IJK + INCREMENT_FOR_kp(CELL_CLASS(IJK))
563       END FUNCTION KP_OF_0
564     
565     
566       !      WEST_OF  (IJK)   = WEST_ARRAY_OF(IJK)
567       !      EAST_OF  (IJK)   = EAST_ARRAY_OF(IJK)
568       !      SOUTH_OF  (IJK)   = SOUTH_ARRAY_OF(IJK)
569       !      NORTH_OF  (IJK)   = NORTH_ARRAY_OF(IJK)
570       !      BOTTOM_OF  (IJK)   = BOTTOM_ARRAY_OF(IJK)
571       !      TOP_OF  (IJK)   = TOP_ARRAY_OF(IJK)
572       !      IM_OF  (IJK)   = IM_ARRAY_OF(IJK)
573       !      IP_OF  (IJK)   = IP_ARRAY_OF(IJK)
574       !      JM_OF  (IJK)   = JM_ARRAY_OF(IJK)
575       !      JP_OF  (IJK)   = JP_ARRAY_OF(IJK)
576       !      KM_OF  (IJK)   = KM_ARRAY_OF(IJK)
577       !      KP_OF  (IJK)   = KP_ARRAY_OF(IJK)
578     
579       INTEGER FUNCTION FUNLM (L1, L2)
580         USE indices
581         IMPLICIT NONE
582         INTEGER L1, L2
583         FUNLM = STORE_LM (L1, L2)
584       END FUNCTION FUNLM
585     
586       LOGICAL FUNCTION FLUID_AT(IJK)
587         USE geometry
588         IMPLICIT NONE
589         INTEGER IJK
590         FLUID_AT    = FLAG(IJK) .EQ. 1
591       END FUNCTION FLUID_AT
592     
593     
594       LOGICAL FUNCTION CYCLIC_AT_E(IJK)
595         USE geometry
596         IMPLICIT NONE
597         INTEGER IJK
598         CYCLIC_AT_E   = FLAG_E(IJK) .EQ. 2000
599       END FUNCTION CYCLIC_AT_E
600     
601       LOGICAL FUNCTION CYCLIC_AT_N(IJK)
602         USE geometry
603         IMPLICIT NONE
604         INTEGER IJK
605         CYCLIC_AT_N   = FLAG_N(IJK) .EQ. 2000
606       END FUNCTION CYCLIC_AT_N
607     
608       LOGICAL FUNCTION CYCLIC_AT_T(IJK)
609         USE geometry
610         IMPLICIT NONE
611         INTEGER IJK
612         CYCLIC_AT_T   = FLAG_T(IJK) .EQ. 2000
613       END FUNCTION CYCLIC_AT_T
614     
615       LOGICAL FUNCTION FLOW_AT_E(IJK)
616         USE geometry
617         IMPLICIT NONE
618         INTEGER IJK
619         FLOW_AT_E   = FLAG_E(IJK) .GE. 2000 .AND.&
620              FLAG_E(IJK) .LE. 2011
621       END FUNCTION FLOW_AT_E
622     
623       LOGICAL FUNCTION FLOW_AT_N(IJK)
624         USE geometry
625         IMPLICIT NONE
626         INTEGER IJK
627         FLOW_AT_N   = FLAG_N(IJK) .GE. 2000 .AND.&
628              FLAG_N(IJK) .LE. 2011
629       END FUNCTION FLOW_AT_N
630     
631       LOGICAL FUNCTION FLOW_AT_T(IJK)
632         USE geometry
633         IMPLICIT NONE
634         INTEGER IJK
635         FLOW_AT_T   = FLAG_T(IJK) .GE. 2000 .AND.&
636              FLAG_T(IJK) .LE. 2011
637       END FUNCTION FLOW_AT_T
638     
639       LOGICAL FUNCTION PFLOW_AT_E(IJK)
640         USE geometry
641         IMPLICIT NONE
642         INTEGER IJK
643         PFLOW_AT_E  = FLAG_E(IJK) .EQ. 2010 .OR.&
644              FLAG_E(IJK) .EQ. 2011
645       END FUNCTION PFLOW_AT_E
646     
647       LOGICAL FUNCTION PFLOW_AT_N(IJK)
648         USE geometry
649         IMPLICIT NONE
650         INTEGER IJK
651         PFLOW_AT_N  = FLAG_N(IJK) .EQ. 2010 .OR.&
652              FLAG_N(IJK) .EQ. 2011
653       END FUNCTION PFLOW_AT_N
654     
655       LOGICAL FUNCTION PFLOW_AT_T(IJK)
656         USE geometry
657         IMPLICIT NONE
658         INTEGER IJK
659         PFLOW_AT_T  = FLAG_T(IJK) .EQ. 2010 .OR.&
660              FLAG_T(IJK) .EQ. 2011
661       END FUNCTION PFLOW_AT_T
662     
663       LOGICAL FUNCTION MFLOW_AT_E(IJK)
664         USE geometry
665         IMPLICIT NONE
666         INTEGER IJK
667         MFLOW_AT_E  = FLAG_E(IJK) .EQ. 2020 .OR. &
668              FLAG_E(IJK) .EQ. 2021 .OR. &
669              FLAG_E(IJK) .EQ. 2031
670       END FUNCTION MFLOW_AT_E
671     
672       LOGICAL FUNCTION MFLOW_AT_N(IJK)
673         USE geometry
674         IMPLICIT NONE
675         INTEGER IJK
676         MFLOW_AT_N  = FLAG_N(IJK) .EQ. 2020 .OR. &
677              FLAG_N(IJK) .EQ. 2021 .OR. &
678              FLAG_N(IJK) .EQ. 2031
679       END FUNCTION MFLOW_AT_N
680     
681       LOGICAL FUNCTION MFLOW_AT_T(IJK)
682         USE geometry
683         IMPLICIT NONE
684         INTEGER IJK
685         MFLOW_AT_T  = FLAG_T(IJK) .EQ. 2020 .OR. &
686              FLAG_T(IJK) .EQ. 2021 .OR. &
687              FLAG_T(IJK) .EQ. 2031
688       END FUNCTION MFLOW_AT_T
689     
690       LOGICAL FUNCTION FLUIDorP_FLOW_AT(IJK)
691         USE geometry
692         IMPLICIT NONE
693         INTEGER IJK
694         FLUIDorP_FLOW_AT = FLAG(IJK) .LE. 11
695       END FUNCTION FLUIDorP_FLOW_AT
696     
697       LOGICAL FUNCTION P_FLOW_AT(IJK)
698         USE geometry
699         IMPLICIT NONE
700         INTEGER IJK
701         P_FLOW_AT = FLAG(IJK) .EQ. 10 .OR. &
702              FLAG(IJK) .EQ. 11
703       END FUNCTION P_FLOW_AT
704     
705       LOGICAL FUNCTION P_OUTFLOW_AT(IJK)
706         USE geometry
707         IMPLICIT NONE
708         INTEGER IJK
709         P_OUTFLOW_AT= FLAG(IJK) .EQ. 11
710       END FUNCTION P_OUTFLOW_AT
711     
712       LOGICAL FUNCTION MASS_OUTFLOW_AT(IJK)
713         USE geometry
714         IMPLICIT NONE
715         INTEGER IJK
716         MASS_OUTFLOW_AT= FLAG(IJK) .EQ. 21
717       END FUNCTION MASS_OUTFLOW_AT
718     
719       LOGICAL FUNCTION OUTFLOW_AT(IJK)
720         USE geometry
721         IMPLICIT NONE
722         INTEGER IJK
723         OUTFLOW_AT  = FLAG(IJK) .EQ. 31
724       END FUNCTION OUTFLOW_AT
725     
726       LOGICAL FUNCTION FLOW_AT(IJK)
727         USE geometry
728         IMPLICIT NONE
729         INTEGER IJK
730         FLOW_AT     = FLAG(IJK) .GE. 10 .AND. FLAG(IJK) .LE. 31
731       END FUNCTION FLOW_AT
732     
733       LOGICAL FUNCTION NS_WALL_AT(IJK)
734         USE geometry
735         IMPLICIT NONE
736         INTEGER IJK
737         NS_WALL_AT  = FLAG(IJK) .EQ. 100
738       END FUNCTION NS_WALL_AT
739     
740       LOGICAL FUNCTION FS_WALL_AT(IJK)
741         USE geometry
742         IMPLICIT NONE
743         INTEGER IJK
744         FS_WALL_AT  = FLAG(IJK) .EQ. 101
745       END FUNCTION FS_WALL_AT
746     
747       LOGICAL FUNCTION PS_WALL_AT(IJK)
748         USE geometry
749         IMPLICIT NONE
750         INTEGER IJK
751         PS_WALL_AT  = FLAG(IJK) .EQ. 102
752       END FUNCTION PS_WALL_AT
753     
754       LOGICAL FUNCTION CYCLIC_AT(IJK)
755         USE geometry
756         IMPLICIT NONE
757         INTEGER IJK
758         CYCLIC_AT = FLAG(IJK) .EQ. 106 .OR. &
759              FLAG(IJK) .EQ. 107
760       END FUNCTION CYCLIC_AT
761     
762       LOGICAL FUNCTION WALL_AT(IJK)
763         USE geometry
764         IMPLICIT NONE
765         INTEGER IJK
766         WALL_AT     = FLAG(IJK) .GE. 100
767       END FUNCTION WALL_AT
768     
769       LOGICAL FUNCTION IP_AT_E(IJK)
770         USE geometry
771         IMPLICIT NONE
772         INTEGER IJK
773         IP_AT_E     = FLAG_E(IJK) .LT. 1000
774       END FUNCTION IP_AT_E
775     
776       LOGICAL FUNCTION IP_AT_N(IJK)
777         USE geometry
778         IMPLICIT NONE
779         INTEGER IJK
780         IP_AT_N     = FLAG_N(IJK) .LT. 1000
781       END FUNCTION IP_AT_N
782     
783       LOGICAL FUNCTION IP_AT_T(IJK)
784         USE geometry
785         IMPLICIT NONE
786         INTEGER IJK
787         IP_AT_T     = FLAG_T(IJK) .LT. 1000
788       END FUNCTION IP_AT_T
789     
790       LOGICAL FUNCTION SIP_AT_E(IJK)
791         USE geometry
792         IMPLICIT NONE
793         INTEGER IJK
794         SIP_AT_E    = (FLAG_E(IJK) .LT. 2000)
795       END FUNCTION SIP_AT_E
796     
797       LOGICAL FUNCTION SIP_AT_N(IJK)
798         USE geometry
799         IMPLICIT NONE
800         INTEGER IJK
801         SIP_AT_N    = (FLAG_N(IJK) .LT. 2000)
802       END FUNCTION SIP_AT_N
803     
804       LOGICAL FUNCTION SIP_AT_T(IJK)
805         USE geometry
806         IMPLICIT NONE
807         INTEGER IJK
808         SIP_AT_T    = (FLAG_T(IJK) .LT. 2000)
809       END FUNCTION SIP_AT_T
810     
811       LOGICAL FUNCTION SP_AT_E(IJK)
812         USE geometry
813         IMPLICIT NONE
814         INTEGER IJK
815         SP_AT_E     = (FLAG_E(IJK) .LT. 2000) .AND. &
816              (FLAG_E(IJK) .GE. 1000)
817       END FUNCTION SP_AT_E
818     
819       LOGICAL FUNCTION SP_AT_N(IJK)
820         USE geometry
821         IMPLICIT NONE
822         INTEGER IJK
823         SP_AT_N     = (FLAG_N(IJK) .LT. 2000) .AND. &
824              (FLAG_N(IJK) .GE. 1000)
825       END FUNCTION SP_AT_N
826     
827       LOGICAL FUNCTION SP_AT_T(IJK)
828         USE geometry
829         IMPLICIT NONE
830         INTEGER IJK
831         SP_AT_T     = (FLAG_T(IJK) .LT. 2000) .AND. &
832              (FLAG_T(IJK) .GE. 1000)
833       END FUNCTION SP_AT_T
834     
835       INTEGER FUNCTION IS_ID_AT_E(IJK)
836         USE geometry
837         IMPLICIT NONE
838         INTEGER IJK
839         IS_ID_AT_E = FLAG_E(IJK) - 1000
840       END FUNCTION IS_ID_AT_E
841     
842       INTEGER FUNCTION IS_ID_AT_N(IJK)
843         USE geometry
844         IMPLICIT NONE
845         INTEGER IJK
846         IS_ID_AT_N  = FLAG_N(IJK) - 1000
847       END FUNCTION IS_ID_AT_N
848     
849       INTEGER FUNCTION IS_ID_AT_T(IJK)
850         USE geometry
851         IMPLICIT NONE
852         INTEGER IJK
853         IS_ID_AT_T  = FLAG_T(IJK) - 1000
854       END FUNCTION IS_ID_AT_T
855     
856       LOGICAL FUNCTION IS_AT_E(IJK)
857         USE geometry
858         IMPLICIT NONE
859         INTEGER IJK
860         IS_AT_E     = FLAG_E(IJK) .LT. 2000
861       END FUNCTION IS_AT_E
862     
863       LOGICAL FUNCTION IS_AT_N(IJK)
864         USE geometry
865         IMPLICIT NONE
866         INTEGER IJK
867         IS_AT_N     = FLAG_N(IJK) .LT. 2000
868       END FUNCTION IS_AT_N
869     
870       LOGICAL FUNCTION IS_AT_T(IJK)
871         USE geometry
872         IMPLICIT NONE
873         INTEGER IJK
874         IS_AT_T     = FLAG_T(IJK) .LT. 2000
875       END FUNCTION IS_AT_T
876     
877       LOGICAL FUNCTION NO_IS_AT_E(IJK)
878         USE geometry
879         IMPLICIT NONE
880         INTEGER IJK
881         NO_IS_AT_E  = FLAG_E(IJK) .GE. 2000
882       END FUNCTION NO_IS_AT_E
883     
884       LOGICAL FUNCTION NO_IS_AT_N(IJK)
885         USE geometry
886         IMPLICIT NONE
887         INTEGER IJK
888         NO_IS_AT_N  = FLAG_N(IJK) .GE. 2000
889       END FUNCTION NO_IS_AT_N
890     
891       LOGICAL FUNCTION NO_IS_AT_T(IJK)
892         USE geometry
893         IMPLICIT NONE
894         INTEGER IJK
895         NO_IS_AT_T  = FLAG_T(IJK) .GE. 2000
896       END FUNCTION NO_IS_AT_T
897     
898       LOGICAL FUNCTION WALL_ICBC_FLAG(IJK)
899         USE geometry
900         IMPLICIT NONE
901         INTEGER, INTENT(IN) :: IJK
902         WALL_ICBC_FLAG = ICBC_FLAG(IJK)(1:1) .EQ. 'W' .OR. &
903              ICBC_FLAG(IJK)(1:1) .EQ. 'S' .OR. &
904              ICBC_FLAG(IJK)(1:1) .EQ. 's' .OR. &
905              ICBC_FLAG(IJK)(1:1) .EQ. 'c' .OR. &
906              ICBC_FLAG(IJK)(1:1) .EQ. 'C'
907       END FUNCTION WALL_ICBC_FLAG
908     
909       LOGICAL FUNCTION DEFAULT_WALL_AT(IJK)
910         USE geometry
911         IMPLICIT NONE
912         INTEGER, INTENT(IN) :: IJK
913         DEFAULT_WALL_AT = ICBC_FLAG(IJK)(2:3) .EQ. '--' .AND. &
914              (ICBC_FLAG(IJK)(1:1) .NE. 'c'  .AND. &
915              ICBC_FLAG(IJK)(1:1) .NE. 'C')
916       END FUNCTION DEFAULT_WALL_AT
917     
918       DOUBLE PRECISION FUNCTION ZMAX(XXX)
919         USE geometry
920         IMPLICIT NONE
921         DOUBLE PRECISION XXX
922         ZMAX       = MAX(XXX, ZERO)
923       END FUNCTION ZMAX
924     
925     END MODULE functions
926