source: CIVL/examples/fortran/nek5000/core/math.f

main
Last change on this file was ea777aa, checked in by Alex Wilton <awilton@…>, 3 years ago

Moved examples, include, build_default.properties, common.xml, and README out from dev.civl.com into the root of the repo.

git-svn-id: svn://vsl.cis.udel.edu/civl/trunk@5704 fb995dde-84ed-4084-dfe6-e5aef3e2452c

  • Property mode set to 100755
File size: 40.4 KB
Line 
1c-----------------------------------------------------------------------
2 subroutine icopy48(a,b,n)
3 integer*8 a(1)
4 integer*4 b(1)
5 do 100 i = 1, n
6 100 a(i) = b(i)
7 return
8 end
9c-----------------------------------------------------------------------
10 subroutine icopy84(a,b,n)
11 integer*4 a(1)
12 integer*8 b(1)
13 do 100 i = 1, n
14 100 a(i) = b(i)
15 return
16 end
17c-----------------------------------------------------------------------
18 SUBROUTINE BLANK(A,N)
19 CHARACTER*1 A(1)
20 CHARACTER*1 BLNK
21 SAVE BLNK
22 DATA BLNK /' '/
23C
24 DO 10 I=1,N
25 A(I)=BLNK
26 10 CONTINUE
27 RETURN
28 END
29c-----------------------------------------------------------------------
30 SUBROUTINE VSQ (A,N)
31 DIMENSION A(1)
32C
33 include 'OPCTR'
34C
35 DO 100 I = 1, N
36 100 A(I) = A(I)**2
37 RETURN
38 END
39c-----------------------------------------------------------------------
40 SUBROUTINE VSQRT(A,N)
41 DIMENSION A(1)
42C
43 include 'OPCTR'
44C
45 DO 100 I = 1, N
46 100 A(I) = SQRT(A(I))
47 RETURN
48 END
49c-----------------------------------------------------------------------
50 subroutine invers2(a,b,n)
51 REAL A(1),B(1)
52C
53 include 'OPCTR'
54C
55 DO 100 I=1,N
56 A(I)=1./B(I)
57 100 CONTINUE
58 return
59 END
60c-----------------------------------------------------------------------
61 subroutine invcol1(a,n)
62 REAL A(1)
63C
64 include 'OPCTR'
65C
66 DO 100 I=1,N
67 A(I)=1./A(I)
68 100 CONTINUE
69 return
70 END
71c-----------------------------------------------------------------------
72 subroutine invcol2(a,b,n)
73C
74 REAL A(1),B(1)
75 include 'CTIMER'
76 include 'OPCTR'
77
78#ifdef TIMER2
79 if (icalld.eq.0) then
80 tinvc=0.0
81 icalld=icalld+1
82 endif
83 etime1=dnekclock()
84#endif
85
86 DO 100 I=1,N
87 A(I)=A(I)/B(I)
88 100 CONTINUE
89
90#ifdef TIMER2
91 tinvc=tinvc+(dnekclock()-etime1)
92#endif
93
94 return
95 END
96c-----------------------------------------------------------------------
97 subroutine invcol3(a,b,c,n)
98 REAL A(1),B(1),C(1)
99C
100 include 'OPCTR'
101 include 'CTIMER'
102
103#ifdef TIMER2
104 if (icalld.eq.0) tinv3=0.0
105 icalld=icalld+1
106 ninv3=icalld
107 etime1=dnekclock()
108#endif
109C
110 DO 100 I=1,N
111 A(I)=B(I)/C(I)
112 100 CONTINUE
113#ifdef TIMER2
114 tinv3=tinv3+(dnekclock()-etime1)
115#endif
116 return
117 END
118c-----------------------------------------------------------------------
119 subroutine col4(a,b,c,d,n)
120 REAL A(1),B(1),C(1),D(1)
121C
122 include 'OPCTR'
123C
124 DO 100 I=1,N
125 A(I)=B(I)*C(I)*D(I)
126 100 CONTINUE
127 return
128 END
129c-----------------------------------------------------------------------
130 subroutine Xaddcol3(a,b,c,n)
131 REAL A(1),B(1),C(1)
132C
133 include 'OPCTR'
134C
135 DO 100 I=1,N
136 A(I)=A(I)+B(I)*C(I)
137 100 CONTINUE
138 return
139 END
140c-----------------------------------------------------------------------
141 subroutine addcol4(a,b,c,d,n)
142 REAL A(1),B(1),C(1),D(1)
143C
144 include 'OPCTR'
145C
146 DO 100 I=1,N
147 A(I)=A(I)+B(I)*C(I)*D(I)
148 100 CONTINUE
149 return
150 END
151c-----------------------------------------------------------------------
152 subroutine ascol5 (a,b,c,d,e,n)
153 REAL A(1),B(1),C(1),D(1),E(1)
154C
155 include 'OPCTR'
156C
157 DO 100 I=1,N
158 A(I) = B(I)*C(I)-D(I)*E(I)
159 100 CONTINUE
160 return
161 END
162c-----------------------------------------------------------------------
163 subroutine sub2(a,b,n)
164 REAL A(1),B(1)
165C
166 include 'OPCTR'
167C
168 DO 100 I=1,N
169 A(I)=A(I)-B(I)
170 100 CONTINUE
171 return
172 END
173c-----------------------------------------------------------------------
174 subroutine sub3(a,b,c,n)
175 REAL A(1),B(1),C(1)
176C
177 include 'OPCTR'
178C
179 DO 100 I=1,N
180 A(I)=B(I)-C(I)
181 100 CONTINUE
182 return
183 END
184c-----------------------------------------------------------------------
185 subroutine subcol3(a,b,c,n)
186 REAL A(1),B(1),C(1)
187C
188 include 'OPCTR'
189C
190 DO 100 I=1,N
191 A(I)=A(I)-B(I)*C(I)
192 100 CONTINUE
193 return
194 END
195c-----------------------------------------------------------------------
196 subroutine subcol4(a,b,c,d,n)
197 REAL A(1),B(1),C(1),D(1)
198C
199 include 'OPCTR'
200C
201 DO 100 I=1,N
202 A(I)=A(I)-B(I)*C(I)*D(I)
203 100 CONTINUE
204 return
205 END
206c-----------------------------------------------------------------------
207 subroutine rzero(a,n)
208 DIMENSION A(1)
209 DO 100 I = 1, N
210 100 A(I ) = 0.0
211 return
212 END
213c-----------------------------------------------------------------------
214 subroutine izero(a,n)
215 INTEGER A(1)
216C
217 DO 100 I = 1, N
218 100 A(I ) = 0
219 return
220 END
221c-----------------------------------------------------------------------
222 subroutine ione(a,n)
223 INTEGER A(1)
224 DO 100 I = 1, N
225 100 A(I ) = 1
226 return
227 END
228c-----------------------------------------------------------------------
229 subroutine rone(a,n)
230 DIMENSION A(1)
231 DO 100 I = 1, N
232 100 A(I ) = 1.0
233 return
234 END
235c-----------------------------------------------------------------------
236 subroutine ltrue(a,n)
237 LOGICAL A(1)
238 DO 100 I = 1, N
239 100 A(I ) = .TRUE.
240 return
241 END
242c-----------------------------------------------------------------------
243 subroutine cfill(a,b,n)
244 DIMENSION A(1)
245C
246 DO 100 I = 1, N
247 100 A(I) = B
248 return
249 END
250c-----------------------------------------------------------------------
251 subroutine ifill(ia,ib,n)
252 DIMENSION IA(1)
253C
254 DO 100 I = 1, N
255 100 IA(I) = IB
256 return
257 END
258c-----------------------------------------------------------------------
259 subroutine copy(a,b,n)
260 real a(1),b(1)
261
262 do i=1,n
263 a(i)=b(i)
264 enddo
265
266 return
267 end
268c-----------------------------------------------------------------------
269 subroutine copyi4(a,b,n)
270 integer a(1)
271 real b(1)
272
273 do i=1,n
274 a(i)=b(i)
275 enddo
276
277 return
278 end
279c-----------------------------------------------------------------------
280 subroutine chcopy(a,b,n)
281 CHARACTER*1 A(1), B(1)
282C
283 DO 100 I = 1, N
284 100 A(I) = B(I)
285 return
286 END
287C
288 subroutine icopy(a,b,n)
289 INTEGER A(1), B(1)
290C
291 DO 100 I = 1, N
292 100 A(I) = B(I)
293 return
294 END
295c-----------------------------------------------------------------------
296 subroutine i8copy(a,b,n)
297 INTEGER*8 A(1), B(1)
298C
299 DO 100 I = 1, N
300 100 A(I) = B(I)
301 return
302 END
303c-----------------------------------------------------------------------
304 subroutine chsign(a,n)
305 REAL A(1)
306C
307 DO 100 I=1,N
308 A(I) = -A(I)
309 100 CONTINUE
310 return
311 END
312C
313c-----------------------------------------------------------------------
314 subroutine cmult(a,const,n)
315 REAL A(1)
316C
317 include 'OPCTR'
318C
319 DO 100 I=1,N
320 A(I)=A(I)*CONST
321 100 CONTINUE
322 return
323 END
324c-----------------------------------------------------------------------
325 subroutine cadd(a,const,n)
326 REAL A(1)
327C
328 include 'OPCTR'
329C
330 DO 100 I=1,N
331 A(I)=A(I)+CONST
332 100 CONTINUE
333 return
334 END
335c-----------------------------------------------------------------------
336 subroutine iadd(i1,iscal,n)
337 DIMENSION I1(1)
338C
339 DO 10 I=1,N
340 I1(I)=I1(I)+ISCAL
341 10 CONTINUE
342 return
343 END
344c-----------------------------------------------------------------------
345 subroutine cadd2(a,b,const,n)
346 REAL A(1),B(1)
347C
348 include 'OPCTR'
349C
350 DO 100 I=1,N
351 A(I)=B(I)+CONST
352 100 CONTINUE
353 return
354 END
355c-----------------------------------------------------------------------
356 real function vlmin(vec,n)
357 REAL VEC(1)
358 TMIN = 99.0E20
359C
360 DO 100 I=1,N
361 TMIN = MIN(TMIN,VEC(I))
362 100 CONTINUE
363 VLMIN = TMIN
364 return
365 END
366c-----------------------------------------------------------------------
367 integer function ivlmin(vec,n)
368 integer vec(1),tmin
369 if (n.eq.0) then
370 ivlmin=0
371 return
372 endif
373 tmin = 8888888
374 do i=1,n
375 tmin = min(tmin,vec(i))
376 enddo
377 ivlmin = tmin
378 return
379 end
380c-----------------------------------------------------------------------
381 integer function ivlmax(vec,n)
382 integer vec(1),tmax
383 if (n.eq.0) then
384 ivlmax=0
385 return
386 endif
387 TMAX =-8888888
388 do i=1,n
389 TMAX = MAX(TMAX,VEC(I))
390 enddo
391 Ivlmax = tmax
392 return
393 end
394c-----------------------------------------------------------------------
395 real function vlmax(vec,n)
396 REAL VEC(1)
397 TMAX =-99.0E20
398 do i=1,n
399 TMAX = MAX(TMAX,VEC(I))
400 enddo
401 VLMAX = TMAX
402 return
403 END
404c-----------------------------------------------------------------------
405 real function vlamax(vec,n)
406 REAL VEC(1)
407 TAMAX = 0.0
408C
409 DO 100 I=1,N
410 TAMAX = MAX(TAMAX,ABS(VEC(I)))
411 100 CONTINUE
412 VLAMAX = TAMAX
413 return
414 END
415c-----------------------------------------------------------------------
416 real function vlsum(vec,n)
417 REAL VEC(1)
418 include 'OPCTR'
419C
420 SUM = 0.
421C
422 DO 100 I=1,N
423 SUM=SUM+VEC(I)
424 100 CONTINUE
425 VLSUM = SUM
426 return
427 END
428c-----------------------------------------------------------------------
429 subroutine vcross (u1,u2,u3,v1,v2,v3,w1,w2,w3,n)
430C
431C Compute a Cartesian vector cross product.
432C
433 DIMENSION U1(1),U2(1),U3(1)
434 DIMENSION V1(1),V2(1),V3(1)
435 DIMENSION W1(1),W2(1),W3(1)
436C
437C
438 DO 100 I=1,N
439 U1(I) = V2(I)*W3(I) - V3(I)*W2(I)
440 U2(I) = V3(I)*W1(I) - V1(I)*W3(I)
441 U3(I) = V1(I)*W2(I) - V2(I)*W1(I)
442 100 CONTINUE
443 return
444 END
445c-----------------------------------------------------------------------
446 subroutine vdot2 (dot,u1,u2,v1,v2,n)
447C
448C Compute a Cartesian vector dot product. 2-d version
449C
450 DIMENSION DOT(1)
451 DIMENSION U1(1),U2(1)
452 DIMENSION V1(1),V2(1)
453C
454C
455 DO 100 I=1,N
456 DOT(I) = U1(I)*V1(I) + U2(I)*V2(I)
457 100 CONTINUE
458 return
459 END
460c-----------------------------------------------------------------------
461 subroutine vdot3 (dot,u1,u2,u3,v1,v2,v3,n)
462C
463C Compute a Cartesian vector dot product. 3-d version
464C
465 DIMENSION DOT(1)
466 DIMENSION U1(1),U2(1),U3(1)
467 DIMENSION V1(1),V2(1),V3(1)
468C
469C
470 DO 100 I=1,N
471 DOT(I) = U1(I)*V1(I) + U2(I)*V2(I) + U3(I)*V3(I)
472 100 CONTINUE
473 return
474 END
475c-----------------------------------------------------------------------
476 subroutine addtnsr(s,h1,h2,h3,nx,ny,nz)
477C
478C Map and add to S a tensor product form of the three functions H1,H2,H3.
479C This is a single element routine used for deforming geometry.
480C
481 DIMENSION H1(1),H2(1),H3(1)
482 DIMENSION S(NX,NY,NZ)
483C
484 DO 200 IZ=1,NZ
485 DO 200 IY=1,NY
486 HH = H2(IY)*H3(IZ)
487 DO 100 IX=1,NX
488 S(IX,IY,IZ)=S(IX,IY,IZ)+HH*H1(IX)
489 100 CONTINUE
490 200 CONTINUE
491 return
492 END
493 function ltrunc(string,l)
494 CHARACTER*1 STRING(L)
495 CHARACTER*1 BLNK
496 DATA BLNK/' '/
497C
498 DO 100 I=L,1,-1
499 L1=I
500 IF (STRING(I).NE.BLNK) GOTO 200
501 100 CONTINUE
502 L1=0
503 200 CONTINUE
504 LTRUNC=L1
505 return
506 END
507c-----------------------------------------------------------------------
508 function mod1(i,n)
509C
510C Yields MOD(I,N) with the exception that if I=K*N, result is N.
511C
512 MOD1=0
513 IF (I.EQ.0) THEN
514 return
515 ENDIF
516 IF (N.EQ.0) THEN
517 WRITE(6,*)
518 $ 'WARNING: Attempt to take MOD(I,0) in function mod1.'
519 return
520 ENDIF
521 II = I+N-1
522 MOD1 = MOD(II,N)+1
523 return
524 END
525c-----------------------------------------------------------------------
526 integer function log2(k)
527 RK=(K)
528 RLOG=LOG10(RK)
529 RLOG2=LOG10(2.0)
530 RLOG=RLOG/RLOG2+0.5
531 LOG2=INT(RLOG)
532 return
533 END
534c-----------------------------------------------------------------------
535 subroutine iflip(i1,n)
536 DIMENSION I1(1)
537 N1=N+1
538 N2=N/2
539 DO 10 I=1,N2
540 ILAST=N1-I
541 ITMP=I1(ILAST)
542 I1(ILAST)=I1(I)
543 I1(I)=ITMP
544 10 CONTINUE
545 return
546 END
547c-----------------------------------------------------------------------
548 subroutine iswap(b,ind,n,temp)
549 INTEGER B(1),IND(1),TEMP(1)
550C***
551C*** SORT ASSOCIATED ELEMENTS BY PUTTING ITEM(JJ)
552C*** INTO ITEM(I), WHERE JJ=IND(I).
553C***
554 DO 20 I=1,N
555 JJ=IND(I)
556 TEMP(I)=B(JJ)
557 20 CONTINUE
558 DO 30 I=1,N
559 30 B(I)=TEMP(I)
560 return
561 END
562c-----------------------------------------------------------------------
563 subroutine col2(a,b,n)
564 real a(1),b(1)
565 include 'OPCTR'
566 include 'CTIMER'
567
568#ifdef TIMER2
569 if (icalld.eq.0) then
570 icalld=1
571 tcol2=0
572 endif
573 etime1=dnekclock()
574#endif
575
576 do i=1,n
577 a(i)=a(i)*b(i)
578 enddo
579
580#ifdef TIMER2
581 tcol2=tcol2+(dnekclock()-etime1)
582#endif
583
584 return
585 end
586c-----------------------------------------------------------------------
587 subroutine col2c(a,b,c,n)
588 real a(1),b(1),c
589
590 do i=1,n
591 a(i)=a(i)*b(i)*c
592 enddo
593
594 return
595 end
596c-----------------------------------------------------------------------
597 subroutine col3(a,b,c,n)
598 real a(1),b(1),c(1)
599 include 'OPCTR'
600 include 'CTIMER'
601
602#ifdef TIMER2
603 if (icalld.eq.0) then
604 icalld=1
605 tcol3=0
606 endif
607 etime1=dnekclock()
608#endif
609
610 do i=1,n
611 a(i)=b(i)*c(i)
612 enddo
613
614#ifdef TIMER2
615 tcol3=tcol3+(dnekclock()-etime1)
616#endif
617
618 return
619 end
620c-----------------------------------------------------------------------
621 subroutine add2(a,b,n)
622 real a(1),b(1)
623 include 'OPCTR'
624 include 'CTIMER'
625
626#ifdef TIMER2
627 if (icalld.eq.0) then
628 icalld=1
629 tadd2=0
630 endif
631 etime1=dnekclock()
632#endif
633 do i=1,n
634 a(i)=a(i)+b(i)
635 enddo
636
637#ifdef TIMER2
638 tadd2=tadd2+(dnekclock()-etime1)
639#endif
640 return
641 end
642c-----------------------------------------------------------------------
643 subroutine add3(a,b,c,n)
644 real a(1),b(1),c(1)
645 include 'OPCTR'
646
647 do i=1,n
648 a(i)=b(i)+c(i)
649 enddo
650 return
651 end
652c-----------------------------------------------------------------------
653 subroutine addcol3(a,b,c,n)
654 real a(1),b(1),c(1)
655 include 'OPCTR'
656 include 'CTIMER'
657
658#ifdef TIMER2
659 if (icalld.eq.0) then
660 icalld=1
661 tadc3=0
662 endif
663 etime1=dnekclock()
664#endif
665
666 do i=1,n
667 a(i)=a(i)+b(i)*c(i)
668 enddo
669
670#ifdef TIMER2
671 tadc3=tadc3+(dnekclock()-etime1)
672#endif
673
674 return
675 end
676c-----------------------------------------------------------------------
677 subroutine add2s1(a,b,c1,n)
678 real a(1),b(1)
679C
680 include 'OPCTR'
681C
682 DO 100 I=1,N
683 A(I)=C1*A(I)+B(I)
684 100 CONTINUE
685 return
686 END
687C
688c-----------------------------------------------------------------------
689 subroutine add2s2(a,b,c1,n)
690 real a(1),b(1)
691C
692 include 'OPCTR'
693 include 'CTIMER'
694C
695#ifdef TIMER2
696 if (icalld.eq.0) then
697 icalld=1
698 ta2s2=0
699 endif
700 etime1=dnekclock()
701#endif
702C
703 DO 100 I=1,N
704 A(I)=A(I)+C1*B(I)
705 100 CONTINUE
706
707#ifdef TIMER2
708 ta2s2=ta2s2+(dnekclock()-etime1)
709#endif
710
711 return
712 END
713C
714c-----------------------------------------------------------------------
715 subroutine add3s2(a,b,c,c1,c2,n)
716 real a(1),b(1),c(1)
717C
718 include 'OPCTR'
719C
720 DO 100 I=1,N
721 A(I)=C1*B(I)+C2*C(I)
722 100 CONTINUE
723 return
724 END
725C
726c-----------------------------------------------------------------------
727 subroutine add4(a,b,c,d,n)
728 REAL A(1),B(1),C(1),D(1)
729C
730 include 'OPCTR'
731C
732 DO 100 I=1,N
733 A(I)=B(I)+C(I)+D(I)
734 100 CONTINUE
735 return
736 END
737c-----------------------------------------------------------------------
738 real function vlsc2(x,y,n)
739 REAL X(1),Y(1)
740 include 'SIZE'
741 include 'OPCTR'
742 include 'PARALLEL'
743C
744 s = 0.
745 do i=1,n
746 s = s + x(i)*y(i)
747 enddo
748 vlsc2=s
749 return
750 end
751c-----------------------------------------------------------------------
752 real function vlsc21(x,y,n)
753 real x(1),y(1)
754 include 'SIZE'
755 include 'OPCTR'
756 include 'PARALLEL'
757C
758 s = 0.
759 do i=1,n
760 s = s + x(i)*x(i)*y(i)
761 enddo
762 vlsc21=s
763 return
764 end
765
766C----------------------------------------------------------------------------
767C
768C Vector reduction routines which require communication
769C on a parallel machine. These routines must be substituted with
770C appropriate routines which take into account the specific architecture.
771C
772C----------------------------------------------------------------------------
773
774
775 function glsc3(a,b,mult,n)
776C
777C Perform inner-product in double precision
778C
779 REAL A(1),B(1),MULT(1)
780 REAL TMP,WORK(1)
781C
782 include 'OPCTR'
783C
784 TMP = 0.0
785 DO 10 I=1,N
786 TMP = TMP + A(I)*B(I)*MULT(I)
787 10 CONTINUE
788 CALL GOP(TMP,WORK,'+ ',1)
789 GLSC3 = TMP
790 return
791 END
792c-----------------------------------------------------------------------
793 function glsc2(x,y,n)
794C
795C Perform inner-product in double precision
796C
797 include 'OPCTR'
798c
799 real x(1), y(1)
800 real tmp,work(1)
801C
802 tmp=0.0
803 do 10 i=1,n
804 tmp = tmp+ x(i)*y(i)
805 10 continue
806 CALL GOP(TMP,WORK,'+ ',1)
807 GLSC2 = TMP
808 return
809 END
810c-----------------------------------------------------------------------
811 function glsc23(x,y,z,n)
812c
813C Perform inner-product x*x*y*z
814c
815 real x(1), y(1),z(1)
816 real tmp,work(1)
817
818 ds = 0.0
819 do 10 i=1,n
820 ds=ds+x(i)*x(i)*y(i)*z(i)
821 10 continue
822 tmp=ds
823 call gop(tmp,work,'+ ',1)
824 glsc23 = tmp
825 return
826 end
827c-----------------------------------------------------------------------
828 real function gl2norm(a,n)
829
830 include 'SIZE'
831 include 'MASS'
832
833 real a(1)
834
835 common /scrsf/ w1 (lx1,ly1,lz1,lelt)
836
837 call col3 (w1,a,a,n)
838 call col2 (w1,bm1,n)
839 gl2norm = sqrt(glsum (w1,n)/volvm1)
840
841 return
842 end
843c-----------------------------------------------------------------------
844 real function gl2norm2(a,n)
845
846 include 'SIZE'
847 include 'MASS'
848
849 real a(n)
850
851 common /scrsf/ w1 (lx2*ly2*lz2*lelt)
852
853 call col3 (w1,a,a,n)
854 call col2 (w1,bm2,n)
855 gl2norm2 = sqrt(glsum (w1,n)/volvm2)
856
857 return
858 end
859c-----------------------------------------------------------------------
860 function glsum (x,n)
861 DIMENSION X(1)
862 DIMENSION TMP(1),WORK(1)
863 TSUM = 0.
864 DO 100 I=1,N
865 TSUM = TSUM+X(I)
866 100 CONTINUE
867 TMP(1)=TSUM
868 CALL GOP(TMP,WORK,'+ ',1)
869 GLSUM = TMP(1)
870 return
871 END
872c-----------------------------------------------------------------------
873 real function glamax(a,n)
874 REAL A(1)
875 DIMENSION TMP(1),WORK(1)
876 TMAX = 0.0
877 DO 100 I=1,N
878 TMAX = MAX(TMAX,ABS(A(I)))
879 100 CONTINUE
880 TMP(1)=TMAX
881 CALL GOP(TMP,WORK,'M ',1)
882 GLAMAX=ABS(TMP(1))
883 return
884 END
885c-----------------------------------------------------------------------
886 real function glamin(a,n)
887 real a(1)
888 dimension tmp(1),work(1)
889 tmin = 9.e28
890 do 100 i=1,n
891 tmin = min(tmin,abs(a(i)))
892 100 continue
893 tmp(1)=tmin
894 call gop(tmp,work,'m ',1)
895 glamin=abs(tmp(1))
896 return
897 end
898c-----------------------------------------------------------------------
899 function iglmin(a,n)
900 integer a(1),tmin
901 integer tmp(1),work(1)
902 tmin= 999999999
903 do i=1,n
904 tmin=min(tmin,a(i))
905 enddo
906 tmp(1)=tmin
907 call igop(tmp,work,'m ',1)
908 iglmin=tmp(1)
909 return
910 end
911c-----------------------------------------------------------------------
912 function iglmax(a,n)
913 integer a(1),tmax
914 integer tmp(1),work(1)
915 tmax= -999999999
916 do i=1,n
917 tmax=max(tmax,a(i))
918 enddo
919 tmp(1)=tmax
920 call igop(tmp,work,'M ',1)
921 iglmax=tmp(1)
922 return
923 end
924c-----------------------------------------------------------------------
925 function iglsum(a,n)
926 integer a(1),tsum
927 integer tmp(1),work(1)
928 tsum= 0
929 do i=1,n
930 tsum=tsum+a(i)
931 enddo
932 tmp(1)=tsum
933 call igop(tmp,work,'+ ',1)
934 iglsum=tmp(1)
935 return
936 end
937c-----------------------------------------------------------------------
938 subroutine i8zero(a,n)
939 integer*8 a(1)
940 do i=1,n
941 a(i)=0
942 enddo
943 return
944 end
945c-----------------------------------------------------------------------
946 integer*8 function i8glsum(a,n)
947 integer*8 a(1),tsum
948 integer*8 tmp(1),work(1)
949 tsum= 0
950 do i=1,n
951 tsum=tsum+a(i)
952 enddo
953 tmp(1)=tsum
954 call i8gop(tmp,work,'+ ',1)
955 i8glsum=tmp(1)
956 return
957 end
958C-----------------------------------------------------------------------
959 function glmax(a,n)
960 REAL A(1)
961 DIMENSION TMP(1),WORK(1)
962 TMAX=-99.0e20
963 DO 100 I=1,N
964 TMAX=MAX(TMAX,A(I))
965 100 CONTINUE
966 TMP(1)=TMAX
967 CALL GOP(TMP,WORK,'M ',1)
968 GLMAX=TMP(1)
969 return
970 END
971c-----------------------------------------------------------------------
972 function glmin(a,n)
973 REAL A(1)
974 DIMENSION TMP(1),WORK(1)
975 TMIN=99.0e20
976 DO 100 I=1,N
977 TMIN=MIN(TMIN,A(I))
978 100 CONTINUE
979 TMP(1)=TMIN
980 CALL GOP(TMP,WORK,'m ',1)
981 GLMIN = TMP(1)
982 return
983 END
984c-----------------------------------------------------------------------
985 subroutine gllog(la,lb)
986C
987C If ANY LA=LB, then ALL LA=LB.
988C
989 LOGICAL LA,LB
990 DIMENSION TMP(1),WORK(1)
991C
992 TMP(1)=1.0
993 IF (LB) THEN
994 IF (LA) TMP(1)=0.0
995 ELSE
996 IF (.NOT.LA) TMP(1)=0.0
997 ENDIF
998 CALL GOP(TMP,WORK,'* ',1)
999 IF (TMP(1).EQ.0.0) LA=LB
1000 return
1001 END
1002c-----------------------------------------------------------------------
1003 function fmdian(a,n,ifok)
1004C find the Median of the (global) set A
1005 include 'SIZE'
1006 DIMENSION A(1)
1007 DIMENSION WORK1(5),WORK2(5)
1008 DIMENSION GUES(100)
1009 LOGICAL IFOK
1010C
1011 AMP =1.5
1012 AFAC =1.5
1013 GMIN =GLMIN(A,N)
1014 GMAX =GLMAX(A,N)
1015 GMIN0=GLMIN(A,N)
1016 GMAX0=GLMAX(A,N)
1017 GUESS=(GMAX+GMIN)/2.0
1018 EPS =(GMAX-GMIN)
1019 IF (EPS.EQ.0.0) THEN
1020 FMDIAN=GMAX
1021 return
1022 ENDIF
1023 WORK1(1)=N
1024 CALL GOP(WORK1,WORK2,'+ ',1)
1025 NTOT=WORK1(1)
1026 N2 = (NTOT+1)/2
1027 IF (.NOT.IFOK) THEN
1028 WRITE(6,8) NID,N,(A(I),I=1,N)
1029 WRITE(6,9) NID,NTOT,N2,N,GMIN,GMAX
1030 8 FORMAT(I5,'N,A:',I5,10(6F10.5,/))
1031 9 FORMAT(I5,'mnx:',3I6,2F10.5)
1032 ENDIF
1033C
1034C This is the trial loop
1035C
1036 ITRY=-1
1037 10 CONTINUE
1038 ITRY=ITRY+1
1039 II=ITRY+1
1040 IF (II.LE.100) GUES(II)=GUESS
1041C error check for infinite loop
1042 IF (ITRY.GT.2*NTOT) GOTO 9000
1043 CALL RZERO(WORK1,5)
1044 NLT=0
1045 NGT=0
1046 CLT=GMIN0
1047 CGT=GMAX0
1048 DO 100 I=1,N
1049 AA=A(I)
1050 IF (AA.NE.GUESS) THEN
1051 IF (AA.LT.GUESS) THEN
1052 NLT=NLT+1
1053C CLT - closest value to GUESS Less Than GUESS
1054 IF (AA.GT.CLT) CLT=AA
1055 ENDIF
1056 IF (AA.GT.GUESS) THEN
1057 NGT=NGT+1
1058C CGT - closest value to GUESS Greater Than GUESS
1059 IF (AA.LT.CGT) CGT=AA
1060 ENDIF
1061 DUM=1./(EPS+ABS(AA-GUESS))
1062 WORK1(1)=WORK1(1)+DUM
1063 WORK1(2)=WORK1(2)+DUM*AA
1064 ELSE
1065C detected values equaling the guess.
1066 WORK1(5)=WORK1(5)+1.0
1067 ENDIF
1068 100 CONTINUE
1069C Invoke vector reduction across processors:
1070 WORK2(1)=CLT
1071 CLT=GLMAX(WORK2,1)
1072 WORK2(1)=CGT
1073 CGT=GLMIN(WORK2,1)
1074 WORK1(3)=NLT
1075 WORK1(4)=NGT
1076 CALL GOP(WORK1,WORK2,'+ ',5)
1077 NLT=WORK1(3)
1078 NGT=WORK1(4)
1079 IF (.NOT.IFOK) THEN
1080 WRITE(6,101) NID,GUESS,CLT,CGT
1081 WRITE(6,102) NID,(WORK1(I),I=1,5)
1082 101 FORMAT(I5,'Glg:',3F12.5)
1083 102 FORMAT(I5,'WORK1:',5F12.5)
1084 ENDIF
1085C
1086C Done?
1087C
1088 IF (NLT.GT.N2.OR.NGT.GT.N2) THEN
1089C we're not done.....
1090 IF (NGT.GT.NLT) THEN
1091C guess is too low
1092 GMIN=CGT
1093 G2=CGT+MAX(0.,WORK1(2)/WORK1(1)-GUESS)*AMP
1094 IF (G2.GT.GMAX) G2=0.5*(GUESS+GMAX)
1095 EPS=AFAC*ABS(G2-GUESS)
1096C see that we move at least as far as the next closest value.
1097 GUESS=MAX(G2,CGT)
1098 GOTO 10
1099 ELSE IF (NLT.GT.NGT) THEN
1100C guess is too high
1101 GMAX=CLT
1102 G2=CLT+MIN(0.,WORK1(2)/WORK1(1)-GUESS)*AMP
1103 IF (G2.LT.GMIN) G2=0.5*(GUESS+GMIN)
1104 EPS=AFAC*ABS(G2-GUESS)
1105C see that we move at least as far as the next closest value.
1106 GUESS=MIN(G2,CLT)
1107 GOTO 10
1108 ENDIF
1109 ELSE
1110C
1111C we're done....
1112 IF (WORK1(5).NE.0) THEN
1113C the median is (usually) one of the values
1114 FMDIAN=GUESS
1115 IF (WORK1(5).EQ.1.0) THEN
1116 IF (MOD(NTOT,2).EQ.0) THEN
1117 IF (NGT.GT.NLT) THEN
1118 FMDIAN=0.5*(GUESS+CGT)
1119 ELSE
1120 FMDIAN=0.5*(GUESS+CLT)
1121 ENDIF
1122 ELSE
1123 IF (NGT.EQ.NLT) THEN
1124 FMDIAN=GUESS
1125 ELSE IF(NGT.GT.NLT) THEN
1126 FMDIAN=CGT
1127 ELSE
1128 FMDIAN=CLT
1129 ENDIF
1130 ENDIF
1131 ENDIF
1132 ELSE
1133 IF (MOD(NTOT,2).EQ.0) THEN
1134 IF (NGT.EQ.NLT) THEN
1135 FMDIAN=0.5*(CLT+CGT)
1136 ELSE IF(NGT.GT.NLT) THEN
1137 FMDIAN=0.5*(GUESS+CGT)
1138 ELSE
1139 FMDIAN=0.5*(GUESS+CLT)
1140 ENDIF
1141 ELSE
1142 IF (NGT.EQ.NLT) THEN
1143 FMDIAN=GUESS
1144 ELSE IF(NGT.GT.NLT) THEN
1145 FMDIAN=CGT
1146 ELSE
1147 FMDIAN=CLT
1148 ENDIF
1149 ENDIF
1150 ENDIF
1151C
1152 ENDIF
1153 IF (.NOT.IFOK) WRITE(6,*) NID,'FMDIAN2',FMDIAN,(A(I),I=1,N)
1154 return
1155C
1156C Error handling
1157C
1158 9000 CONTINUE
1159 WRITE(6,11) NTOT,GMIN0,GMAX0,GUESS
1160 11 FORMAT('ABORTING IN FMDIAN: N,AMIN,AMAX:',I6,3G14.6)
1161 DO 13 I1=1,N,5
1162 IN=I1+5
1163 IN=MIN(IN,N)
1164 WRITE(6,12) NID,(A(I),I=I1,IN)
1165 12 FORMAT(I4,' FMA:',5G14.6)
1166 13 CONTINUE
1167 DO 15 I1=1,ITRY,5
1168 IN=I1+5
1169 IN=MIN(IN,ITRY)
1170 WRITE(6,14) NID,(GUES(I),I=I1,IN)
1171 14 FORMAT(I4,' FMG:',5G14.6)
1172 15 CONTINUE
1173 call exitt
1174 END
1175
1176C========================================================================
1177C Double precision matrix and vector routines
1178C========================================================================
1179
1180c-----------------------------------------------------------------------
1181 subroutine dcadd(a,const,n)
1182 real*8 A(1),CONST
1183C
1184 DO 100 I=1,N
1185 A(I)=A(I)+CONST
1186 100 CONTINUE
1187 return
1188 END
1189c-----------------------------------------------------------------------
1190 subroutine dsub2(a,b,n)
1191 real*8 A(1), B(1)
1192C
1193 DO 100 I=1,N
1194 A(I)=A(I)-B(I)
1195 100 CONTINUE
1196 return
1197 END
1198C
1199c-----------------------------------------------------------------------
1200 subroutine dadd2(a,b,n)
1201 real*8 A(1), B(1)
1202C
1203 DO 100 I=1,N
1204 A(I)=A(I)+B(I)
1205 100 CONTINUE
1206 return
1207 END
1208c-----------------------------------------------------------------------
1209 subroutine chswapr(b,L,ind,n,temp)
1210 INTEGER IND(1)
1211 CHARACTER*6 B(1),TEMP(1)
1212C***
1213C*** SORT ASSOCIATED ELEMENTS BY PUTTING ITEM(JJ)
1214C*** INTO ITEM(I), WHERE JJ=IND(I).
1215C***
1216 DO 20 I=1,N
1217 JJ=IND(I)
1218 TEMP(I)=B(JJ)
1219 20 CONTINUE
1220 DO 30 I=1,N
1221 30 B(I)=TEMP(I)
1222 return
1223 END
1224c-----------------------------------------------------------------------
1225 subroutine drcopy(r,d,N)
1226 real*8 d(1)
1227 dimension r(1)
1228 do 10 i=1,n
1229 r(i)=d(i)
1230 10 continue
1231 return
1232 end
1233c-----------------------------------------------------------------------
1234 subroutine rrcopy(r,d,N)
1235 real*4 d(1)
1236 real*4 r(1)
1237 do 10 i=1,n
1238 r(i)=d(i)
1239 10 continue
1240 return
1241 end
1242c-----------------------------------------------------------------------
1243 subroutine sorts(xout,xin,work,n)
1244 real xout(1),xin(1),work(1)
1245 call copy(xout,xin,n)
1246 call sort(xout,work,n)
1247 return
1248 end
1249C
1250c-----------------------------------------------------------------------
1251 function ivlsum(a,n)
1252 INTEGER A(1)
1253 INTEGER TSUM
1254 if (n.eq.0) then
1255 ivlsum = 0
1256 return
1257 endif
1258 TSUM=A(1)
1259 DO 100 I=2,N
1260 TSUM=TSUM+A(I)
1261 100 CONTINUE
1262 IVLSUM=TSUM
1263 return
1264 END
1265c-----------------------------------------------------------------------
1266 subroutine icadd(a,c,n)
1267 INTEGER A(1),C
1268 DO 100 I = 1, N
1269 100 A(I) = A(I) + C
1270 return
1271 END
1272 subroutine isort(a,ind,n)
1273C
1274C Use Heap Sort (p 231 Num. Rec., 1st Ed.)
1275C
1276 integer a(1),ind(1)
1277 integer aa
1278C
1279 dO 10 j=1,n
1280 ind(j)=j
1281 10 continue
1282C
1283 if (n.le.1) return
1284 L=n/2+1
1285 ir=n
1286 100 continue
1287 if (l.gt.1) then
1288 l=l-1
1289 aa = a (l)
1290 ii = ind(l)
1291 else
1292 aa = a(ir)
1293 ii = ind(ir)
1294 a(ir) = a( 1)
1295 ind(ir) = ind( 1)
1296 ir=ir-1
1297 if (ir.eq.1) then
1298 a(1) = aa
1299 ind(1) = ii
1300 return
1301 endif
1302 endif
1303 i=l
1304 j=l+l
1305 200 continue
1306 if (j.le.ir) then
1307 if (j.lt.ir) then
1308 if ( a(j).lt.a(j+1) ) j=j+1
1309 endif
1310 if (aa.lt.a(j)) then
1311 a(i) = a(j)
1312 ind(i) = ind(j)
1313 i=j
1314 j=j+j
1315 else
1316 j=ir+1
1317 endif
1318 GOTO 200
1319 endif
1320 a(i) = aa
1321 ind(i) = ii
1322 GOTO 100
1323 end
1324 subroutine sort(a,ind,n)
1325C
1326C Use Heap Sort (p 231 Num. Rec., 1st Ed.)
1327C
1328 real a(1),aa
1329 integer ind(1)
1330C
1331 dO 10 j=1,n
1332 ind(j)=j
1333 10 continue
1334C
1335 if (n.le.1) return
1336 L=n/2+1
1337 ir=n
1338 100 continue
1339 if (l.gt.1) then
1340 l=l-1
1341 aa = a (l)
1342 ii = ind(l)
1343 else
1344 aa = a(ir)
1345 ii = ind(ir)
1346 a(ir) = a( 1)
1347 ind(ir) = ind( 1)
1348 ir=ir-1
1349 if (ir.eq.1) then
1350 a(1) = aa
1351 ind(1) = ii
1352 return
1353 endif
1354 endif
1355 i=l
1356 j=l+l
1357 200 continue
1358 if (j.le.ir) then
1359 if (j.lt.ir) then
1360 if ( a(j).lt.a(j+1) ) j=j+1
1361 endif
1362 if (aa.lt.a(j)) then
1363 a(i) = a(j)
1364 ind(i) = ind(j)
1365 i=j
1366 j=j+j
1367 else
1368 j=ir+1
1369 endif
1370 GOTO 200
1371 endif
1372 a(i) = aa
1373 ind(i) = ii
1374 GOTO 100
1375 end
1376c-----------------------------------------------------------------------
1377 subroutine iswap_ip(x,p,n)
1378 integer x(1),xstart
1379 integer p(1)
1380c
1381c In-place permutation: x' = x(p)
1382c
1383 do k=1,n
1384 if (p(k).gt.0) then ! not swapped
1385 xstart = x(k)
1386 loop_start = k
1387 last = k
1388 do j=k,n
1389 next = p(last)
1390 if (next.lt.0) then
1391 write(6,*) 'Hey! iswap_ip problem.',j,k,n,next
1392 call exitt
1393 elseif (next.eq.loop_start) then
1394 x(last) = xstart
1395 p(last) = -p(last)
1396 goto 10
1397 else
1398 x(last) = x(next)
1399 p(last) = -p(last)
1400 last = next
1401 endif
1402 enddo
1403 10 continue
1404 endif
1405 enddo
1406c
1407 do k=1,n
1408 p(k) = -p(k)
1409 enddo
1410 return
1411 end
1412c-----------------------------------------------------------------------
1413 subroutine iswapt_ip(x,p,n)
1414 integer x(1),t1,t2
1415 integer p(1)
1416c
1417c In-place permutation: x'(p) = x
1418c
1419
1420 do k=1,n
1421 if (p(k).gt.0) then ! not swapped
1422 loop_start = k
1423 next = p(loop_start)
1424 t1 = x(loop_start)
1425 do j=1,n
1426 if (next.lt.0) then
1427 write(6,*) 'Hey! iswapt_ip problem.',j,k,n,next
1428 call exitt
1429 elseif (next.eq.loop_start) then
1430 x(next) = t1
1431 p(next) = -p(next)
1432 goto 10
1433 else
1434 t2 = x(next)
1435 x(next) = t1
1436 t1 = t2
1437 nextp = p(next)
1438 p(next) = -p(next)
1439 next = nextp
1440 endif
1441 enddo
1442 10 continue
1443 endif
1444 enddo
1445c
1446 do k=1,n
1447 p(k) = -p(k)
1448 enddo
1449 return
1450 end
1451c-----------------------------------------------------------------------
1452 subroutine swap_ip(x,p,n)
1453 real x(1),xstart
1454 integer p(1)
1455c
1456c In-place permutation: x' = x(p)
1457c
1458 do k=1,n
1459 if (p(k).gt.0) then ! not swapped
1460 xstart = x(k)
1461 loop_start = k
1462 last = k
1463 do j=k,n
1464 next = p(last)
1465 if (next.lt.0) then
1466 write(6,*) 'Hey! swap_ip problem.',j,k,n,next
1467 call exitt
1468 elseif (next.eq.loop_start) then
1469 x(last) = xstart
1470 p(last) = -p(last)
1471 goto 10
1472 else
1473 x(last) = x(next)
1474 p(last) = -p(last)
1475 last = next
1476 endif
1477 enddo
1478 10 continue
1479 endif
1480 enddo
1481c
1482 do k=1,n
1483 p(k) = -p(k)
1484 enddo
1485 return
1486 end
1487c-----------------------------------------------------------------------
1488 subroutine swapt_ip(x,p,n)
1489 real x(1),t1,t2
1490 integer p(1)
1491c
1492c In-place permutation: x'(p) = x
1493c
1494
1495 do k=1,n
1496 if (p(k).gt.0) then ! not swapped
1497 loop_start = k
1498 next = p(loop_start)
1499 t1 = x(loop_start)
1500 do j=1,n
1501 if (next.lt.0) then
1502 write(6,*) 'Hey! swapt_ip problem.',j,k,n,next
1503 call exitt
1504 elseif (next.eq.loop_start) then
1505 x(next) = t1
1506 p(next) = -p(next)
1507 goto 10
1508 else
1509 t2 = x(next)
1510 x(next) = t1
1511 t1 = t2
1512 nextp = p(next)
1513 p(next) = -p(next)
1514 next = nextp
1515 endif
1516 enddo
1517 10 continue
1518 endif
1519 enddo
1520c
1521 do k=1,n
1522 p(k) = -p(k)
1523 enddo
1524 return
1525 end
1526c-----------------------------------------------------------------------
1527 subroutine glvadd(x,w,n)
1528 real x(1),w(1)
1529 call gop(x,w,'+ ',n)
1530 return
1531 end
1532c-----------------------------------------------------------------------
1533 subroutine add3s12(x,y,z,c1,c2,n)
1534 real x(1),y(1),z(1),c1,c2
1535 do i=1,n
1536 x(i) = c1*y(i)+c2*z(i)
1537 enddo
1538 return
1539 end
1540c-----------------------------------------------------------------------
1541 integer*8 function i8glmax(a,n)
1542 integer*8 a(1),tmax
1543 integer*8 tmp(1),work(1)
1544 tmax= -999999
1545 do i=1,n
1546 tmax=max(tmax,a(i))
1547 enddo
1548 tmp(1)=tmax
1549 call i8gop(tmp,work,'M ',1)
1550 i8glmax=tmp(1)
1551 if (i8glmax .eq. -999999) i8glmax=0
1552 return
1553 end
1554c-----------------------------------------------------------------------
1555 subroutine admcol3(a,b,c,d,n)
1556 REAL A(1),B(1),C(1),D
1557C
1558 DO 100 I=1,N
1559 A(I)=A(I)+B(I)*C(I)*D
1560 100 CONTINUE
1561 return
1562 END
1563c-----------------------------------------------------------------------
1564 subroutine add2col2(a,b,c,n)
1565 real a(1),b(1),c(1)
1566c
1567 do i=1,n
1568 a(i) = a(i) + b(i)*c(i)
1569 enddo
1570 return
1571 end
1572c-----------------------------------------------------------------------
1573 subroutine add2sxy(x,a,y,b,n)
1574 real x(1),y(1)
1575c
1576 do i=1,n
1577 x(i) = a*x(i) + b*y(i)
1578 enddo
1579c
1580 return
1581 end
1582c-----------------------------------------------------------------------
1583 subroutine col2s2(x,y,s,n)
1584 real x(n),y(n)
1585c
1586 do i=1,n
1587 x(i)=s*x(i)*y(i)
1588 enddo
1589c
1590 return
1591 end
1592cc-----------------------------------------------------------------------
1593 subroutine transpose(a,lda,b,ldb)
1594 real a(lda,1),b(ldb,1)
1595c
1596 do j=1,ldb
1597 do i=1,lda
1598 a(i,j) = b(j,i)
1599 enddo
1600 enddo
1601 return
1602 end
1603c-----------------------------------------------------------------------
1604 subroutine transpose1(a,n)
1605 real a(n,n)
1606c
1607 do j=1,n
1608 do i=j+1,n
1609 ta = a(i,j)
1610 a(i,j) = a(j,i)
1611 a(j,i) = ta
1612 enddo
1613 enddo
1614 return
1615 end
1616c-----------------------------------------------------------------------
1617 real function difmax(a,b,n)
1618 real a(1),b(1)
1619
1620 d=0
1621 do i=1,n
1622 diff = abs(a(i)-b(i))
1623 d = max(d,diff)
1624 enddo
1625 difmax = glamax(d,1)
1626
1627 return
1628 end
1629c-----------------------------------------------------------------------
1630ccc Nek-Nek routines
1631c-----------------------------------------------------------------------
1632 function glmin_ms(a,n)
1633 include 'SIZE'
1634 include 'PARALLEL'
1635 real a(1)
1636
1637 call setnekcomm(iglobalcomm)
1638 glmin_ms = glmin(a,n)
1639 call setnekcomm(intracomm)
1640
1641 return
1642 end
1643c-----------------------------------------------------------------------
1644 function glamin_ms(a,n)
1645 include 'SIZE'
1646 include 'PARALLEL'
1647 real a(1)
1648
1649 call setnekcomm(iglobalcomm)
1650 glamin_ms = glamin(a,n)
1651 call setnekcomm(intracomm)
1652
1653 return
1654 end
1655c-----------------------------------------------------------------------
1656 function glmax_ms(a,n)
1657 include 'SIZE'
1658 include 'PARALLEL'
1659 real a(1)
1660
1661 call setnekcomm(iglobalcomm)
1662 glmax_ms = glmax(a,n)
1663 call setnekcomm(intracomm)
1664
1665 return
1666 end
1667c------------------------------------------------------------------------
1668 function glamax_ms(a,n)
1669 include 'SIZE'
1670 include 'PARALLEL'
1671 real a(1)
1672
1673 call setnekcomm(iglobalcomm)
1674 glamax_ms = glamax(a,n)
1675 call setnekcomm(intracomm)
1676
1677 return
1678 end
1679c------------------------------------------------------------------------
1680 function glsum_ms(a,n)
1681 include 'SIZE'
1682 include 'PARALLEL'
1683 real a(1)
1684
1685 call setnekcomm(iglobalcomm)
1686 glsum_ms = glsum(a,n)
1687 call setnekcomm(intracomm)
1688
1689 return
1690 end
1691c-----------------------------------------------------------------------
1692 function iglsum_ms(a,n)
1693 include 'SIZE'
1694 include 'PARALLEL'
1695 integer a(1),n
1696
1697 call setnekcomm(iglobalcomm)
1698 iglsum_ms = iglsum(a,n)
1699 call setnekcomm(intracomm)
1700
1701 return
1702 end
1703c-----------------------------------------------------------------------
1704 function glsc3_ms(a,b,c,n)
1705 include 'SIZE'
1706 include 'PARALLEL'
1707 real a(1),b(1),c(1)
1708
1709 call setnekcomm(iglobalcomm)
1710 glsc3_ms = glsc3(a,b,c,n)
1711 call setnekcomm(intracomm)
1712
1713 return
1714 end
1715c-----------------------------------------------------------------------
1716 function glsc2_ms(a,b,n)
1717 include 'SIZE'
1718 include 'PARALLEL'
1719 real a(1),b(1)
1720
1721 call setnekcomm(iglobalcomm)
1722 glsc2_ms = glsc2(a,b,n)
1723 call setnekcomm(intracomm)
1724
1725 return
1726 end
1727c-----------------------------------------------------------------------
1728 function iglmax_ms(a,n)
1729 include 'SIZE'
1730 include 'PARALLEL'
1731 integer a(1)
1732
1733 call setnekcomm(iglobalcomm)
1734 iglmax_ms = iglmax(a,n)
1735 call setnekcomm(intracomm)
1736
1737 return
1738 end
1739c-----------------------------------------------------------------------
1740 function iglmin_ms(a,n)
1741 include 'SIZE'
1742 include 'PARALLEL'
1743 integer a(1)
1744
1745 call setnekcomm(iglobalcomm)
1746 iglmin_ms = iglmin(a,n)
1747 call setnekcomm(intracomm)
1748
1749 return
1750 end
1751c-----------------------------------------------------------------------
Note: See TracBrowser for help on using the repository browser.