Debian Codegraph @

nemesis/forbind/addrwrpn.F

raw
1 C Copyright (c) 1998 Sandia Corporation. Under the terms of Contract
2 C DE-AC04-94AL85000 with Sandia Corporation, the U.S. Governement
3 C retains certain rights in this software.
4 C
5 C Redistribution and use in source and binary forms, with or without
6 C modification, are permitted provided that the following conditions are
7 C met:
8 C
9 C * Redistributions of source code must retain the above copyright
10 C notice, this list of conditions and the following disclaimer.
11 C
12 C * Redistributions in binary form must reproduce the above
13 C copyright notice, this list of conditions and the following
14 C disclaimer in the documentation and/or other materials provided
15 C with the distribution.
16 C
17 C * Neither the name of Sandia Corporation nor the names of its
18 C contributors may be used to endorse or promote products derived
19 C from this software without specific prior written permission.
20 C
21 C THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 C "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 C LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 C A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 C OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 C SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 C LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 C DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 C THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 C (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 C OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 C
33
34 subroutine adrdumn
35 end
36
37 #ifdef Build64
38 C-----------------------------------------------------------------------
39 C
40 C Get initial information from nemesis file
41 C
42 subroutine negii (idne, nproc, nproc_in_f, ftype, ierr)
43 implicit none
44 integer idne
45 integer nproc
46 integer nproc_in_f
47 character*(*) ftype
48 integer ierr
49 C
50 integer*4 idne4
51 integer*4 nproc4
52 integer*4 nproc_in_f4
53 integer*4 ierr4
54 C
55 idne4 = idne
56 call negii4 (idne4, nproc4, nproc_in_f4, ftype, ierr4)
57 nproc = nproc4
58 nproc_in_f = nproc_in_f4
59 ierr = ierr4
60 C
61 end
62
63 C-----------------------------------------------------------------------
64 C
65 C Write initial information from nemesis file
66 C
67 subroutine nepii (idne, nproc, nproc_in_f, ftype, ierr)
68 implicit none
69 integer idne
70 integer nproc
71 integer nproc_in_f
72 character*(*) ftype
73 integer ierr
74 C
75 integer*4 idne4
76 integer*4 nproc4
77 integer*4 nproc_in_f4
78 integer*4 ierr4
79 C
80 idne4 = idne
81 nproc4 = nproc
82 nproc_in_f4 = nproc_in_f
83 call nepii4 (idne4, nproc4, nproc_in_f4, ftype, ierr4)
84 ierr = ierr4
85 C
86 end
87
88 C-----------------------------------------------------------------------
89 C
90 C Read initial global information
91 C
92 subroutine negig (idne, nnodes_g, nelems_g, nelem_blks_g,
93 $ nnode_sets_g, nside_sets_g, ierr)
94 implicit none
95 integer idne
96 integer nnodes_g
97 integer nelems_g
98 integer nelem_blks_g
99 integer nnode_sets_g
100 integer nside_sets_g
101 integer ierr
102 C
103 integer*4 idne4
104 integer*4 ierr4
105 C
106 idne4 = idne
107 call negig4 (idne4, nnodes_g, nelems_g, nelem_blks_g,
108 $ nnode_sets_g, nside_sets_g, ierr4)
109 ierr = ierr4
110 C
111 end
112
113 C-----------------------------------------------------------------------
114 C
115 C Write initial global information
116 C
117 subroutine nepig (idne, nnodes_g, nelems_g, nelem_blks_g,
118 $ nnode_sets_g, nside_sets_g, ierr)
119 implicit none
120 integer idne
121 integer nnodes_g
122 integer nelems_g
123 integer nelem_blks_g
124 integer nnode_sets_g
125 integer nside_sets_g
126 integer ierr
127 C
128 integer*4 idne4
129 integer*4 ierr4
130 C
131 idne4 = idne
132 call nepig4 (idne4, nnodes_g, nelems_g, nelem_blks_g,
133 $ nnode_sets_g, nside_sets_g, ierr4)
134 ierr = ierr4
135 C
136 end
137
138 C-----------------------------------------------------------------------
139 C
140 C Read load balance parameters
141 C
142 subroutine neglbp (idne, nint_nodes, nbor_nodes, next_nodes,
143 $ nint_elems, nbor_elems, nnode_cmaps, nelem_cmaps,
144 $ processor, ierr)
145 implicit none
146 integer idne
147 integer nint_nodes
148 integer nbor_nodes
149 integer next_nodes
150 integer nint_elems
151 integer nbor_elems
152 integer nnode_cmaps
153 integer nelem_cmaps
154 integer processor
155 integer ierr
156 C
157 integer*4 idne4
158 integer*4 processor4
159 integer*4 ierr4
160 C
161 idne4 = idne
162 processor4 = processor
163 call neglbp4 (idne4, nint_nodes, nbor_nodes, next_nodes,
164 $ nint_elems, nbor_elems, nnode_cmaps, nelem_cmaps,
165 $ processor4, ierr4)
166 ierr = ierr4
167 C
168 end
169
170 C-----------------------------------------------------------------------
171 C
172 C Write load balance parameters
173 C
174 subroutine neplbp (idne, nint_nodes, nbor_nodes, next_nodes,
175 $ nint_elems, nbor_elems, nnode_cmaps, nelem_cmaps,
176 $ processor, ierr)
177 implicit none
178 integer idne
179 integer nint_nodes
180 integer nbor_nodes
181 integer next_nodes
182 integer nint_elems
183 integer nbor_elems
184 integer nnode_cmaps
185 integer nelem_cmaps
186 integer processor
187 integer ierr
188 C
189 integer*4 idne4
190 integer*4 processor4
191 integer*4 ierr4
192 C
193 idne4 = idne
194 processor4 = processor
195 call neplbp4 (idne4, nint_nodes, nbor_nodes, next_nodes,
196 $ nint_elems, nbor_elems, nnode_cmaps, nelem_cmaps,
197 $ processor4, ierr4)
198 ierr = ierr4
199 C
200 end
201
202 C-----------------------------------------------------------------------
203 C
204 C Write concatenated load balance parameters
205 C
206 subroutine neplbpc (idne, nint_nodes, nbor_nodes, next_nodes,
207 $ nint_elems, nbor_elems, nnode_cmaps, nelem_cmaps, ierr)
208 implicit none
209 integer idne
210 integer nint_nodes(*)
211 integer nbor_nodes(*)
212 integer next_nodes(*)
213 integer nint_elems(*)
214 integer nbor_elems(*)
215 integer nnode_cmaps(*)
216 integer nelem_cmaps(*)
217 integer ierr
218 C
219 integer*4 idne4
220 integer*4 ierr4
221 C
222 idne4 = idne
223 call neplbpc4 (idne4, nint_nodes, nbor_nodes, next_nodes,
224 $ nint_elems, nbor_elems, nnode_cmaps, nelem_cmaps,
225 $ ierr4)
226 ierr = ierr4
227 C
228 end
229
230 C-----------------------------------------------------------------------
231 C
232 C Read global node set parameters
233 C
234 subroutine negnspg (idne, ns_ids_glob, ns_n_cnt_glob,
235 $ ns_df_cnt_glob, ierr)
236 implicit none
237 integer idne
238 integer ns_ids_glob(*)
239 integer ns_n_cnt_glob(*)
240 integer ns_df_cnt_glob(*)
241 integer ierr
242 C
243 integer*4 idne4
244 integer*4 ierr4
245 C
246 idne4 = idne
247 call negnspg4 (idne4, ns_ids_glob, ns_n_cnt_glob,
248 $ ns_df_cnt_glob, ierr4)
249 ierr = ierr4
250 C
251 end
252
253 C-----------------------------------------------------------------------
254 C
255 C Write global node set parameters
256 C
257 subroutine nepnspg (idne, global_ids, global_n_cnts,
258 $ global_df_cnts, ierr)
259 integer idne
260 integer global_ids(*)
261 integer global_n_cnts(*)
262 integer global_df_cnts(*)
263 integer ierr
264 C
265 integer*4 idne4
266 integer*4 ierr4
267 C
268 idne4 = idne
269 call nepnspg4 (idne4, global_ids, global_n_cnts,
270 $ global_df_cnts, ierr4)
271 ierr = ierr4
272 C
273 end
274
275 C-----------------------------------------------------------------------
276 C
277 C Read global side set parameters
278 C
279 subroutine negsspg (idne, ss_ids_glob, ss_n_cnt_glob,
280 $ ss_df_cnt_glob, ierr)
281 implicit none
282 integer idne
283 integer ss_ids_glob(*)
284 integer ss_n_cnt_glob(*)
285 integer ss_df_cnt_glob(*)
286 integer ierr
287 C
288 integer*4 idne4
289 integer*4 ierr4
290 C
291 idne4 = idne
292 call negsspg4 (idne4, ss_ids_glob, ss_n_cnt_glob,
293 $ ss_df_cnt_glob, ierr4)
294 ierr = ierr4
295 C
296 end
297
298 C-----------------------------------------------------------------------
299 C
300 C Write global side set parameters
301 C
302 subroutine nepsspg (idne, global_ids, global_el_cnts,
303 $ global_df_cnts, ierr)
304 implicit none
305 integer idne
306 integer global_ids(*)
307 integer global_el_cnts(*)
308 integer global_df_cnts(*)
309 integer ierr
310 C
311 integer*4 idne4
312 integer*4 ierr4
313 C
314 idne4 = idne
315 call nepsspg4 (idne4, global_ids, global_el_cnts,
316 $ global_df_cnts, ierr4)
317 ierr = ierr4
318 C
319 end
320
321 C-----------------------------------------------------------------------
322 C
323 C Read global element block information
324 C
325 subroutine negebig (idne, el_blk_ids, el_blk_cnts, ierr)
326 implicit none
327 integer idne
328 integer el_blk_ids(*)
329 integer el_blk_cnts(*)
330 integer ierr
331 C
332 integer*4 idne4
333 integer*4 ierr4
334 C
335 idne4 = idne
336 call negebig4 (idne4, el_blk_ids, el_blk_cnts, ierr4)
337 ierr = ierr4
338 C
339 end
340
341 C-----------------------------------------------------------------------
342 C
343 C Write global element block information
344 C
345 subroutine nepebig (idne, el_blk_ids, el_blk_cnts, ierr)
346 implicit none
347 integer idne
348 integer el_blk_ids(*)
349 integer el_blk_cnts(*)
350 integer ierr
351 C
352 integer*4 idne4
353 integer*4 ierr4
354 C
355 idne4 = idne
356 call nepebig4 (idne4, el_blk_ids, el_blk_cnts, ierr4)
357 ierr = ierr4
358 C
359 end
360
361 C-----------------------------------------------------------------------
362 C
363 C Read side set element list and side set side list
364 C
365 subroutine negnss (idne, ss_id, start_side_num, num_sides,
366 $ ss_elem_list, ss_side_list, ierr)
367 implicit none
368 integer idne
369 integer ss_id
370 integer start_side_num
371 integer num_sides
372 integer ss_elem_list(num_sides)
373 integer ss_side_list(num_sides)
374 integer ierr
375 C
376 integer*4 idne4
377 integer*4 ierr4
378 C
379 idne4 = idne
380 call negnss4 (idne4, ss_id, start_side_num, num_sides,
381 $ ss_elem_list, ss_side_list, ierr4)
382 ierr = ierr4
383 C
384 end
385
386 C-----------------------------------------------------------------------
387 C
388 C Write side set element list and side set side list
389 C
390 subroutine nepnss (idne, ss_id, start_side_num, num_sides,
391 $ ss_elem_list, ss_side_list, ierr)
392 implicit none
393 integer idne
394 integer ss_id
395 integer start_side_num
396 integer num_sides
397 integer ss_elem_list(num_sides)
398 integer ss_side_list(num_sides)
399 integer ierr
400 C
401 integer*4 idne4
402 integer*4 ierr4
403 C
404 idne4 = idne
405 call nepnss4 (idne4, ss_id, start_side_num, num_sides,
406 $ ss_elem_list, ss_side_list, ierr4)
407 ierr = ierr4
408 C
409 end
410
411 C-----------------------------------------------------------------------
412 C
413 C Read side set distribution factor
414 C
415 subroutine negnssd (idne, ss_id, start_num, num_df_to_get,
416 $ ss_df, ierr)
417 implicit none
418 integer idne
419 integer ss_id
420 integer start_num
421 integer num_df_to_get
422 real ss_df(num_df_to_get)
423 integer ierr
424 C
425 integer*4 idne4
426 integer*4 ierr4
427 C
428 idne4 = idne
429 call negnssd4 (idne4, ss_id, start_num, num_df_to_get,
430 $ ss_df, ierr4)
431 ierr = ierr4
432 C
433 end
434
435 C-----------------------------------------------------------------------
436 C
437 C Write side set distribution factor
438 C
439 subroutine nepnssd (idne, ss_id, start_num, num_df_to_get,
440 $ ss_df, ierr)
441 implicit none
442 integer idne
443 integer ss_id
444 integer start_num
445 integer num_df_to_get
446 real ss_df(num_df_to_get)
447 integer ierr
448 C
449 integer*4 idne4
450 integer*4 ierr4
451 C
452 idne4 = idne
453 call nepnssd4 (idne4, ss_id, start_num, num_df_to_get,
454 $ ss_df, ierr4)
455 ierr = ierr4
456 C
457 end
458
459 C-----------------------------------------------------------------------
460 C
461 C Read node set list for a single node set
462 C
463 subroutine negnns (idne, ns_id, start_node_num, num_node,
464 $ ns_node_list, ierr)
465 implicit none
466 integer idne
467 integer ns_id
468 integer start_node_num
469 integer num_node
470 integer ns_node_list(num_node)
471 integer ierr
472 C
473 integer*4 idne4
474 integer*4 ierr4
475 C
476 idne4 = idne
477 call negnns4 (idne4, ns_id, start_node_num, num_node,
478 $ ns_node_list, ierr4)
479 ierr = ierr4
480 C
481 end
482
483 C-----------------------------------------------------------------------
484 C
485 C Write node set list for a single node set
486 C
487 subroutine nepnns (idne, ns_id, start_node_num, num_node,
488 $ ns_node_list, ierr)
489 implicit none
490 integer idne
491 integer ns_id
492 integer start_node_num
493 integer num_node
494 integer ns_node_list(num_node)
495 integer ierr
496 C
497 integer*4 idne4
498 integer*4 ierr4
499 C
500 idne4 = idne
501 call nepnns4 (idne4, ns_id, start_node_num, num_node,
502 $ ns_node_list, ierr4)
503 ierr = ierr4
504 C
505 end
506
507 C-----------------------------------------------------------------------
508 C
509 C Read node set distribution factor
510 C
511 subroutine negnnsd (idne, ns_id, start_num, num_df_to_get,
512 $ ns_df, ierr)
513 implicit none
514 integer idne
515 integer ns_id
516 integer start_num
517 integer num_df_to_get
518 real ns_df(num_df_to_get)
519 integer ierr
520 C
521 integer*4 idne4
522 integer*4 ierr4
523 C
524 idne4 = idne
525 call negnnsd4 (idne4, ns_id, start_num, num_df_to_get,
526 $ ns_df, ierr4)
527 ierr = ierr4
528 C
529 end
530
531 C-----------------------------------------------------------------------
532 C
533 C Write node set distribution factor
534 C
535 subroutine nepnnsd (idne, ns_id, start_num, num_df_to_get,
536 $ ns_df, ierr)
537 implicit none
538 integer idne
539 integer ns_id
540 integer start_num
541 integer num_df_to_get
542 real ns_df(num_df_to_get)
543 integer ierr
544 C
545 integer*4 idne4
546 integer*4 ierr4
547 C
548 idne4 = idne
549 call nepnnsd4 (idne4, ns_id, start_num, num_df_to_get,
550 $ ns_df, ierr4)
551 ierr = ierr4
552 C
553 end
554
555 C-----------------------------------------------------------------------
556 C
557 C Read coordinates of the nodes
558 C
559 subroutine negcor (idne, start_node_num, num_nodes, x_coor,
560 $ y_coor, z_coor, ierr)
561 implicit none
562 integer idne
563 integer start_node_num
564 integer num_nodes
565 real x_coor(num_nodes)
566 real y_coor(num_nodes)
567 real z_coor(num_nodes)
568 integer ierr
569 C
570 integer*4 idne4
571 integer*4 ierr4
572 C
573 idne4 = idne
574 call negcor4 (idne4, start_node_num, num_nodes, x_coor,
575 $ y_coor, z_coor, ierr4)
576 ierr = ierr4
577 C
578 end
579
580 C-----------------------------------------------------------------------
581 C
582 C Write coordinates of the nodes
583 C
584 subroutine nepcor (idne, start_node_num, num_nodes, x_coor,
585 $ y_coor, z_coor, ierr)
586 implicit none
587 integer idne
588 integer start_node_num
589 integer num_nodes
590 real x_coor(num_nodes)
591 real y_coor(num_nodes)
592 real z_coor(num_nodes)
593 integer ierr
594 C
595 integer*4 idne4
596 integer*4 ierr4
597 C
598 idne4 = idne
599 call nepcor4 (idne4, start_node_num, num_nodes, x_coor,
600 $ y_coor, z_coor, ierr4)
601 ierr = ierr4
602 C
603 end
604
605 C-----------------------------------------------------------------------
606 C
607 C Read an element blocks connectivity list
608 C
609 subroutine negnec (idne, elem_blk_id, start_elem_num,
610 $ num_elems, connect, ierr)
611 implicit none
612 integer idne
613 integer elem_blk_id
614 integer start_elem_num
615 integer num_elems
616 integer connect(num_elems)
617 integer ierr
618 C
619 integer*4 idne4
620 integer*4 ierr4
621 C
622 idne4 = idne
623 call negnec4 (idne4, elem_blk_id, start_elem_num,
624 $ num_elems, connect, ierr4)
625 ierr = ierr4
626 C
627 end
628
629 C-----------------------------------------------------------------------
630 C
631 C Write an element blocks connectivity list
632 C
633 subroutine nepnec (idne, elem_blk_id, start_elem_num,
634 $ num_elems, connect, ierr)
635 implicit none
636 integer idne
637 integer elem_blk_id
638 integer start_elem_num
639 integer num_elems
640 integer connect(num_elems)
641 integer ierr
642 C
643 integer*4 idne4
644 integer*4 ierr4
645 C
646 idne4 = idne
647 call nepnec4 (idne4, elem_blk_id, start_elem_num,
648 $ num_elems, connect, ierr4)
649 ierr = ierr4
650 C
651 end
652
653 C-----------------------------------------------------------------------
654 C
655 C Read an element blocks attributes
656 C
657 subroutine negneat (idne, elem_blk_id, start_elem_num,
658 $ num_elems, attrib, ierr)
659 implicit none
660 integer idne
661 integer elem_blk_id
662 integer start_elem_num
663 integer num_elems
664 real attrib(num_elems)
665 integer ierr
666 C
667 integer*4 idne4
668 integer*4 ierr4
669 C
670 idne4 = idne
671 call negneat4 (idne4, elem_blk_id, start_elem_num,
672 $ num_elems, attrib, ierr4)
673 ierr = ierr4
674 C
675 end
676
677 C-----------------------------------------------------------------------
678 C
679 C Write an element blocks attributes
680 C
681 subroutine nepneat (idne, elem_blk_id, start_elem_num,
682 $ num_elems, attrib, ierr)
683 implicit none
684 integer idne
685 integer elem_blk_id
686 integer start_elem_num
687 integer num_elems
688 real attrib(num_elems)
689 integer ierr
690 C
691 integer*4 idne4
692 integer*4 ierr4
693 C
694 idne4 = idne
695 call nepneat4 (idne4, elem_blk_id, start_elem_num,
696 $ num_elems, attrib, ierr4)
697 ierr = ierr4
698 C
699 end
700 C
701 C-----------------------------------------------------------------------
702 C Read the element type for a specific element block
703 C
704 subroutine negelt (idne, elem_blk_id, elem_type, ierr)
705 implicit none
706 integer idne
707 integer elem_blk_id
708 character*(*) elem_type
709 integer ierr
710 C
711 integer*4 idne4
712 integer*4 ierr4
713 C
714 idne4 = idne
715 call negelt4 (idne4, elem_blk_id, elem_type, ierr4)
716 ierr = ierr4
717 C
718 end
719
720 C-----------------------------------------------------------------------
721 C
722 C Read a variable for an element block
723 C
724 subroutine negnev (idne, time_step, elem_var_index,
725 $ elem_blk_id, num_elem_this_blk, start_elem_num,
726 $ num_elem, elem_var_vals, ierr)
727 implicit none
728 integer idne
729 integer time_step
730 integer elem_var_index
731 integer elem_blk_id
732 integer num_elem_this_blk
733 integer start_elem_num
734 integer num_elem
735 real elem_var_vals(num_elem)
736 integer ierr
737 C
738 integer*4 idne4
739 integer*4 time_step4
740 integer*4 elem_var_index4
741 integer*4 ierr4
742 C
743 idne4 = idne
744 time_step4 = time_step
745 elem_var_index4 = elem_var_index
746 call negnev4 (idne4, time_step4, elem_var_index4,
747 $ elem_blk_id, num_elem_this_blk, start_elem_num,
748 $ num_elem, elem_var_vals, ierr4)
749 ierr = ierr4
750 C
751 end
752
753 C-----------------------------------------------------------------------
754 C
755 C Write a variable slab for an element block
756 C
757 subroutine nepevs (idne, time_step, elem_var_index,
758 $ elem_blk_id, start_pos, num_vals, elem_var_vals,
759 $ ierr)
760 implicit none
761 integer idne
762 integer time_step
763 integer elem_var_index
764 integer elem_blk_id
765 integer start_pos
766 integer num_vals
767 real elem_var_vals(num_vals)
768 integer ierr
769 C
770 integer*4 idne4
771 integer*4 time_step4
772 integer*4 elem_var_index4
773 integer*4 ierr4
774 C
775 idne4 = idne
776 time_step4 = time_step
777 elem_var_index4 = elem_var_index
778 call nepevs4 (idne4, time_step4, elem_var_index4,
779 $ elem_blk_id, start_pos, num_vals, elem_var_vals,
780 $ ierr4)
781 ierr = ierr4
782 C
783 end
784
785 C-----------------------------------------------------------------------
786 C
787 C Read the values of a single nodal variable for a single time step
788 C
789 subroutine negnnv (idne, time_step, nodal_var_index,
790 $ start_node_num, num_nodes, nodal_vars, ierr)
791 implicit none
792 integer idne
793 integer time_step
794 integer nodal_var_index
795 integer start_node_num
796 integer num_nodes
797 real nodal_vars(num_nodes)
798 integer ierr
799 C
800 integer*4 idne4
801 integer*4 time_step4
802 integer*4 nodal_var_index4
803 integer*4 ierr4
804 C
805 idne4 = idne
806 time_step4 = time_step
807 nodal_var_index4 = nodal_var_index
808 call negnnv4 (idne4, time_step4, nodal_var_index4,
809 $ start_node_num, num_nodes, nodal_vars, ierr4)
810 ierr = ierr4
811 C
812 end
813
814 C-----------------------------------------------------------------------
815 C
816 C Write nodal variable slab
817 C
818 subroutine nepnvs (idne, time_step, nodal_var_index,
819 $ start_pos, num_vals, nodal_var_vals, ierr)
820 implicit none
821 integer idne
822 integer time_step
823 integer nodal_var_index
824 integer start_pos
825 integer num_vals
826 real nodal_var_vals(num_vals)
827 integer ierr
828 C
829 integer*4 idne4
830 integer*4 time_step4
831 integer*4 nodal_var_index4
832 integer*4 ierr4
833 C
834 idne4 = idne
835 time_step4 = time_step
836 nodal_var_index4 = nodal_var_index
837 call nepnvs4 (idne4, time_step4, nodal_var_index4,
838 $ start_pos, num_vals, nodal_var_vals, ierr4)
839 ierr = ierr4
840 C
841 end
842
843 C-----------------------------------------------------------------------
844 C
845 C Read the element numbering map
846 C
847 subroutine negnenm (idne, starte, num_ent, elem_map, ierr)
848 implicit none
849 integer idne
850 integer starte
851 integer num_ent
852 integer elem_map(num_ent)
853 integer ierr
854 C
855 integer*4 idne4
856 integer*4 ierr4
857 C
858 idne4 = idne
859 call negnenm4 (idne4, starte, num_ent, elem_map, ierr4)
860 ierr = ierr4
861 C
862 end
863
864 C-----------------------------------------------------------------------
865 C
866 C Write the element numbering map
867 C
868 subroutine nepnenm (idne, starte, num_ent, elem_map, ierr)
869 implicit none
870 integer idne
871 integer starte
872 integer num_ent
873 integer elem_map(num_ent)
874 integer ierr
875 C
876 integer*4 idne4
877 integer*4 ierr4
878 C
879 idne4 = idne
880 call nepnenm4 (idne4, starte, num_ent, elem_map, ierr4)
881 ierr = ierr4
882 C
883 end
884
885 C-----------------------------------------------------------------------
886 C
887 C Read the node numbering map
888 C
889 subroutine negnnnm (idne, startn, num_ent, node_map, ierr)
890 implicit none
891 integer idne
892 integer startn
893 integer num_ent
894 integer node_map(num_ent)
895 integer ierr
896 C
897 integer*4 idne4
898 integer*4 ierr4
899 C
900 idne4 = idne
901 call negnnnm4 (idne4, startn, num_ent, node_map, ierr4)
902 ierr = ierr4
903 C
904 end
905
906 C-----------------------------------------------------------------------
907 C
908 C Write the node numbering map
909 C
910 subroutine nepnnnm (idne, startn, num_ent, node_map, ierr)
911 implicit none
912 integer idne
913 integer startn
914 integer num_ent
915 integer node_map(num_ent)
916 integer ierr
917 C
918 integer*4 idne4
919 integer*4 ierr4
920 C
921 idne4 = idne
922 call nepnnnm4 (idne4, startn, num_ent, node_map, ierr4)
923 ierr = ierr4
924 C
925 end
926
927 C-----------------------------------------------------------------------
928 C
929 C Read the node map for a processor
930 C
931 subroutine negnm (idne, node_mapi, node_mapb, node_mape,
932 $ processor, ierr)
933 implicit none
934 integer idne
935 integer node_mapi(*)
936 integer node_mapb(*)
937 integer node_mape(*)
938 integer processor
939 integer ierr
940 C
941 integer*4 idne4
942 integer*4 processor4
943 integer*4 ierr4
944 C
945 idne4 = idne
946 processor4 = processor
947 call negnm4 (idne4, node_mapi, node_mapb, node_mape,
948 $ processor4, ierr4)
949 ierr = ierr4
950 C
951 end
952
953 C-----------------------------------------------------------------------
954 C
955 C Write a node map for a processor
956 C
957 subroutine nepnm (idne, node_mapi, node_mapb, node_mape,
958 $ processor, ierr)
959 implicit none
960 integer idne
961 integer node_mapi(*)
962 integer node_mapb(*)
963 integer node_mape(*)
964 integer processor
965 integer ierr
966 C
967 integer*4 idne4
968 integer*4 processor4
969 integer*4 ierr4
970 C
971 idne4 = idne
972 processor4 = processor
973 call nepnm4 (idne4, node_mapi, node_mapb, node_mape,
974 $ processor4, ierr4)
975 ierr = ierr4
976 C
977 end
978
979 C-----------------------------------------------------------------------
980 C
981 C Read the element map for a processor
982 C
983 subroutine negem (idne, elem_mapi, elem_mapb, processor, ierr)
984 implicit none
985 integer idne
986 integer elem_mapi(*)
987 integer elem_mapb(*)
988 integer processor
989 integer ierr
990 C
991 integer*4 idne4
992 integer*4 processor4
993 integer*4 ierr4
994 C
995 idne4 = idne
996 processor4 = processor
997 call negem4 (idne4, elem_mapi, elem_mapb, processor4, ierr4)
998 ierr = ierr4
999 C
1000 end
1001
1002 C-----------------------------------------------------------------------
1003 C
1004 C Write the element map for a processor
1005 C
1006 subroutine nepem (idne, elem_mapi, elem_mapb, processor, ierr)
1007 implicit none
1008 integer idne
1009 integer elem_mapi(*)
1010 integer elem_mapb(*)
1011 integer processor
1012 integer ierr
1013 C
1014 integer*4 idne4
1015 integer*4 processor4
1016 integer*4 ierr4
1017 C
1018 idne4 = idne
1019 processor4 = processor
1020 call nepem4 (idne4, elem_mapi, elem_mapb, processor4, ierr4)
1021 ierr = ierr4
1022 C
1023 end
1024
1025 C-----------------------------------------------------------------------
1026 C
1027 C Read the communications map parameters for a single processor
1028 C
1029 subroutine negcmp (idne, ncmap_ids, ncmap_node_cnts,
1030 $ ecmap_ids, ecmap_elem_cnts, processor, ierr)
1031 implicit none
1032 integer idne
1033 integer ncmap_ids(*)
1034 integer ncmap_node_cnts(*)
1035 integer ecmap_ids(*)
1036 integer ecmap_elem_cnts(*)
1037 integer processor
1038 integer ierr
1039 C
1040 integer*4 idne4
1041 integer*4 processor4
1042 integer*4 ierr4
1043 C
1044 idne4 = idne
1045 processor4 = processor
1046 call negcmp4 (idne4, ncmap_ids, ncmap_node_cnts,
1047 $ ecmap_ids, ecmap_elem_cnts, processor4, ierr4)
1048 ierr = ierr4
1049 C
1050 end
1051
1052 C-----------------------------------------------------------------------
1053 C
1054 C Write the communications map parameters for a single processor
1055 C
1056 subroutine nepcmp (idne, nmap_ids, nmap_node_cnts, emap_ids,
1057 $ emap_elem_cnts, processor, ierr)
1058 implicit none
1059 integer idne
1060 integer nmap_ids(*)
1061 integer nmap_node_cnts(*)
1062 integer emap_ids(*)
1063 integer emap_elem_cnts(*)
1064 integer processor
1065 integer ierr
1066
1067 integer*4 idne4
1068 integer*4 processor4
1069 integer*4 ierr4
1070 C
1071 idne4 = idne
1072 processor4 = processor
1073 call nepcmp4 (idne4, nmap_ids, nmap_node_cnts, emap_ids,
1074 $ emap_elem_cnts, processor4, ierr4)
1075 ierr = ierr4
1076 C
1077 end
1078
1079 C-----------------------------------------------------------------------
1080 C
1081 C Write the communications map parameters for all processors
1082 C
1083 subroutine nepcmpc (idne, nmap_ids, nmap_node_cnts,
1084 $ nproc_ptrs, emap_ids, emap_elem_cnts, eproc_ptrs, ierr)
1085 implicit none
1086 integer idne
1087 integer nmap_ids(*)
1088 integer nmap_node_cnts(*)
1089 integer nproc_ptrs(*)
1090 integer emap_ids(*)
1091 integer emap_elem_cnts(*)
1092 integer eproc_ptrs(*)
1093 integer ierr
1094
1095 integer*4 idne4
1096 integer*4 ierr4
1097 C
1098 idne4 = idne
1099 call nepcmpc4 (idne4, nmap_ids, nmap_node_cnts,
1100 $ nproc_ptrs, emap_ids, emap_elem_cnts, eproc_ptrs, ierr4)
1101 ierr = ierr4
1102
1103 end
1104
1105 C-----------------------------------------------------------------------
1106 C
1107 C Read the nodal communications map for a single processor
1108 C
1109 subroutine negncm (idne, map_id, node_ids, proc_ids,
1110 $ processor, ierr)
1111 implicit none
1112 integer idne
1113 integer map_id
1114 integer node_ids(*)
1115 integer proc_ids(*)
1116 integer processor
1117 integer ierr
1118 C
1119 integer*4 idne4
1120 integer*4 processor4
1121 integer*4 ierr4
1122 C
1123 idne4 = idne
1124 processor4 = processor
1125 call negncm4 (idne4, map_id, node_ids, proc_ids,
1126 $ processor4, ierr4)
1127 ierr = ierr4
1128 C
1129 end
1130
1131 C-----------------------------------------------------------------------
1132 C
1133 C Write the nodal communications map for a single processor
1134 C
1135 subroutine nepncm (idne, map_id, node_ids, proc_ids,
1136 $ processor, ierr)
1137 implicit none
1138 integer idne
1139 integer map_id
1140 integer node_ids(*)
1141 integer proc_ids(*)
1142 integer processor
1143 integer ierr
1144 C
1145 integer*4 idne4
1146 integer*4 processor4
1147 integer*4 ierr4
1148 C
1149 idne4 = idne
1150 processor4 = processor
1151 call nepncm4 (idne4, map_id, node_ids, proc_ids,
1152 $ processor4, ierr4)
1153 ierr = ierr4
1154 C
1155 end
1156
1157 C-----------------------------------------------------------------------
1158 C
1159 C Read the elemental communications map for a single processor
1160 C
1161 subroutine negecm (idne, map_id, elem_ids, side_ids,
1162 $ proc_ids, processor, ierr)
1163 implicit none
1164 integer idne
1165 integer map_id
1166 integer elem_ids(*)
1167 integer side_ids(*)
1168 integer proc_ids(*)
1169 integer processor
1170 integer ierr
1171
1172 integer*4 idne4
1173 integer*4 processor4
1174 integer*4 ierr4
1175 C
1176 idne4 = idne
1177 processor4 = processor
1178 call negecm4 (idne4, map_id, elem_ids, side_ids,
1179 $ proc_ids, processor4, ierr4)
1180 ierr = ierr4
1181 C
1182 end
1183
1184 C-----------------------------------------------------------------------
1185 C
1186 C Write the elemental communications map for a single processor
1187 C
1188 subroutine nepecm (idne, map_id, elem_ids, side_ids,
1189 $ proc_ids, processor, ierr)
1190 implicit none
1191 integer idne
1192 integer map_id
1193 integer elem_ids(*)
1194 integer side_ids(*)
1195 integer proc_ids(*)
1196 integer processor
1197 integer ierr
1198
1199 integer*4 idne4
1200 integer*4 processor4
1201 integer*4 ierr4
1202
1203 idne4 = idne
1204 processor4 = processor
1205 call nepecm4 (idne4, map_id, elem_ids, side_ids,
1206 $ proc_ids, processor4, ierr4)
1207 ierr = ierr4
1208
1209 end
1210 C-----------------------------------------------------------------------
1211 #endif