308 |
for (i0=0; i0<chunkSize*numDim; i0++) tempCoords[i0] = -1.0; |
for (i0=0; i0<chunkSize*numDim; i0++) tempCoords[i0] = -1.0; |
309 |
chunkNodes = 0; |
chunkNodes = 0; |
310 |
for (i1=0; i1<chunkSize; i1++) { |
for (i1=0; i1<chunkSize; i1++) { |
311 |
if (totalNodes >= numNodes) break; /* Maybe end the infinite loop */ |
if (totalNodes >= numNodes) break; /* End of inner loop */ |
312 |
if (1 == numDim) |
if (1 == numDim) |
313 |
fscanf(fileHandle_p, "%d %d %d %le\n", |
fscanf(fileHandle_p, "%d %d %d %le\n", |
314 |
&tempInts[0+i1], &tempInts[chunkSize+i1], &tempInts[chunkSize*2+i1], |
&tempInts[0+i1], &tempInts[chunkSize+i1], &tempInts[chunkSize*2+i1], |
343 |
Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: send of tempCoords failed"); |
Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: send of tempCoords failed"); |
344 |
return NULL; |
return NULL; |
345 |
} |
} |
|
nextCPU++; |
|
346 |
} |
} |
347 |
#endif |
#endif |
348 |
if (totalNodes >= numNodes) break; /* Maybe end the infinite loop */ |
nextCPU++; |
349 |
|
/* Infinite loop ends when I've read a chunk for each of the worker nodes plus one more chunk for the master */ |
350 |
|
if (nextCPU > mpi_info->size) break; /* End infinite loop */ |
351 |
} /* Infinite loop */ |
} /* Infinite loop */ |
352 |
} /* End master */ |
} /* End master */ |
353 |
else { /* Worker */ |
else { /* Worker */ |
369 |
#endif |
#endif |
370 |
} /* Worker */ |
} /* Worker */ |
371 |
|
|
|
#if 0 |
|
|
/* Display the temp mem for debugging */ |
|
|
printf("ksteube Nodes tempInts\n"); |
|
|
for (i0=0; i0<chunkSize*3; i0++) { |
|
|
printf(" %2d", tempInts[i0]); |
|
|
if (i0%chunkSize==chunkSize-1) printf("\n"); |
|
|
} |
|
|
printf("ksteube tempCoords:\n"); |
|
|
for (i0=0; i0<chunkSize*numDim; i0++) { |
|
|
printf(" %20.15e", tempCoords[i0]); |
|
|
if (i0%numDim==numDim-1) printf("\n"); |
|
|
} |
|
|
printf("ksteube numDim=%d numNodes=%d mesh name='%s' chunkNodes=%d numNodes=%d\n", numDim, numNodes, name, chunkNodes, numNodes); |
|
|
#endif |
|
|
|
|
372 |
/* Copy node data from tempMem to mesh_p */ |
/* Copy node data from tempMem to mesh_p */ |
373 |
Finley_NodeFile_allocTable(mesh_p->Nodes, chunkNodes); |
Finley_NodeFile_allocTable(mesh_p->Nodes, chunkNodes); |
374 |
if (Finley_noError()) { |
if (Finley_noError()) { |
413 |
} |
} |
414 |
} |
} |
415 |
|
|
416 |
/* Read the element data */ |
/* Allocate the ElementFile */ |
417 |
mesh_p->Elements=Finley_ElementFile_alloc(typeID,mesh_p->order, mesh_p->reduced_order, mpi_info); |
mesh_p->Elements=Finley_ElementFile_alloc(typeID,mesh_p->order, mesh_p->reduced_order, mpi_info); |
418 |
numNodes = mesh_p->Elements->ReferenceElement->Type->numNodes; /* New meaning for numNodes: num nodes per element */ |
numNodes = mesh_p->Elements->ReferenceElement->Type->numNodes; /* New meaning for numNodes: num nodes per element */ |
419 |
|
|
420 |
|
/* Read the element data */ |
421 |
if (Finley_noError()) { |
if (Finley_noError()) { |
422 |
int chunkSize = numEle / mpi_info->size + 1, totalEle=0, nextCPU=1; |
int chunkSize = numEle / mpi_info->size + 1, totalEle=0, nextCPU=1; |
423 |
int *tempInts = TMPMEMALLOC(chunkSize*(2+numNodes)+1, index_t); /* Store Id + Tag + node list (+ one int at end for chunkEle) */ |
int *tempInts = TMPMEMALLOC(chunkSize*(2+numNodes)+1, index_t); /* Store Id + Tag + node list (+ one int at end for chunkEle) */ |
427 |
for (i0=0; i0<chunkSize*(2+numNodes)+1; i0++) tempInts[i0] = -1; |
for (i0=0; i0<chunkSize*(2+numNodes)+1; i0++) tempInts[i0] = -1; |
428 |
chunkEle = 0; |
chunkEle = 0; |
429 |
for (i0=0; i0<chunkSize; i0++) { |
for (i0=0; i0<chunkSize; i0++) { |
430 |
if (totalEle >= numEle) break; /* End infinite loop */ |
if (totalEle >= numEle) break; /* End inner loop */ |
431 |
fscanf(fileHandle_p, "%d %d", &tempInts[i0*(2+numNodes)+0], &tempInts[i0*(2+numNodes)+1]); |
fscanf(fileHandle_p, "%d %d", &tempInts[i0*(2+numNodes)+0], &tempInts[i0*(2+numNodes)+1]); |
432 |
for (i1 = 0; i1 < numNodes; i1++) fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]); |
for (i1 = 0; i1 < numNodes; i1++) fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]); |
433 |
fscanf(fileHandle_p, "\n"); |
fscanf(fileHandle_p, "\n"); |
444 |
Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: send of tempInts for Elements failed"); |
Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: send of tempInts for Elements failed"); |
445 |
return NULL; |
return NULL; |
446 |
} |
} |
|
nextCPU++; |
|
447 |
} |
} |
448 |
#endif |
#endif |
449 |
if (totalEle >= numEle) break; /* End infinite loop */ |
nextCPU++; |
450 |
|
/* Infinite loop ends when I've read a chunk for each of the worker nodes plus one more chunk for the master */ |
451 |
|
if (nextCPU > mpi_info->size) break; /* End infinite loop */ |
452 |
} /* Infinite loop */ |
} /* Infinite loop */ |
453 |
} /* End master */ |
} /* End master */ |
454 |
else { /* Worker */ |
else { /* Worker */ |
465 |
#endif |
#endif |
466 |
} /* Worker */ |
} /* Worker */ |
467 |
|
|
|
#if 0 |
|
|
/* Display the temp mem for debugging */ |
|
|
for (i0=0; i0<chunkSize*(numNodes+2); i0++) { |
|
|
printf(" %2d", tempInts[i0]); |
|
|
if (i0%(numNodes+2)==numNodes+2-1) printf("\n"); |
|
|
} |
|
|
#endif |
|
|
|
|
468 |
/* Copy Element data from tempInts to mesh_p */ |
/* Copy Element data from tempInts to mesh_p */ |
469 |
Finley_ElementFile_allocTable(mesh_p->Elements, chunkEle); |
Finley_ElementFile_allocTable(mesh_p->Elements, chunkEle); |
470 |
mesh_p->Elements->minColor=0; |
mesh_p->Elements->minColor=0; |
482 |
} |
} |
483 |
|
|
484 |
TMPMEMFREE(tempInts); |
TMPMEMFREE(tempInts); |
485 |
} |
} /* end of Read the element data */ |
486 |
|
|
487 |
|
/* read face elements */ |
488 |
|
|
489 |
|
/* Read the element typeID */ |
490 |
|
if (Finley_noError()) { |
491 |
|
if (mpi_info->rank == 0) { |
492 |
|
fscanf(fileHandle_p, "%s %d\n", element_type, &numEle); |
493 |
|
typeID=Finley_RefElement_getTypeId(element_type); |
494 |
|
} |
495 |
|
#ifdef PASO_MPI |
496 |
|
if (mpi_info->size > 1) { |
497 |
|
int temp1[2], mpi_error; |
498 |
|
temp1[0] = (int) typeID; |
499 |
|
temp1[1] = numEle; |
500 |
|
mpi_error = MPI_Bcast (temp1, 2, MPI_INT, 0, mpi_info->comm); |
501 |
|
if (mpi_error != MPI_SUCCESS) { |
502 |
|
Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: broadcast of Element typeID failed"); |
503 |
|
return NULL; |
504 |
|
} |
505 |
|
typeID = (ElementTypeId) temp1[0]; |
506 |
|
numEle = temp1[1]; |
507 |
|
} |
508 |
|
#endif |
509 |
|
if (typeID==NoType) { |
510 |
|
sprintf(error_msg, "Finley_Mesh_read: Unidentified element type %s", element_type); |
511 |
|
Finley_setError(VALUE_ERROR, error_msg); |
512 |
|
} |
513 |
|
} |
514 |
|
|
515 |
|
/* Allocate the ElementFile */ |
516 |
|
mesh_p->FaceElements=Finley_ElementFile_alloc(typeID,mesh_p->order, mesh_p->reduced_order, mpi_info); |
517 |
|
numNodes = mesh_p->FaceElements->ReferenceElement->Type->numNodes; /* New meaning for numNodes: num nodes per element */ |
518 |
|
|
519 |
|
/* Read the face element data */ |
520 |
|
if (Finley_noError()) { |
521 |
|
int chunkSize = numEle / mpi_info->size + 1, totalEle=0, nextCPU=1; |
522 |
|
int *tempInts = TMPMEMALLOC(chunkSize*(2+numNodes)+1, index_t); /* Store Id + Tag + node list (+ one int at end for chunkEle) */ |
523 |
|
/* Elements are specified as a list of integers...only need one message instead of two as with the nodes */ |
524 |
|
if (mpi_info->rank == 0) { /* Master */ |
525 |
|
for (;;) { /* Infinite loop */ |
526 |
|
for (i0=0; i0<chunkSize*(2+numNodes)+1; i0++) tempInts[i0] = -1; |
527 |
|
chunkEle = 0; |
528 |
|
for (i0=0; i0<chunkSize; i0++) { |
529 |
|
if (totalEle >= numEle) break; /* End inner loop */ |
530 |
|
fscanf(fileHandle_p, "%d %d", &tempInts[i0*(2+numNodes)+0], &tempInts[i0*(2+numNodes)+1]); |
531 |
|
for (i1 = 0; i1 < numNodes; i1++) fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]); |
532 |
|
fscanf(fileHandle_p, "\n"); |
533 |
|
totalEle++; |
534 |
|
chunkEle++; |
535 |
|
} |
536 |
|
#ifdef PASO_MPI |
537 |
|
/* Eventually we'll send chunk of elements to each CPU except 0 itself, here goes one of them */ |
538 |
|
if (nextCPU < mpi_info->size) { |
539 |
|
int mpi_error; |
540 |
|
tempInts[chunkSize*(2+numNodes)] = chunkEle; |
541 |
|
mpi_error = MPI_Send(tempInts, chunkSize*(2+numNodes)+1, MPI_INT, nextCPU, 81723, mpi_info->comm); |
542 |
|
if ( mpi_error != MPI_SUCCESS ) { |
543 |
|
Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: send of tempInts for FaceElements failed"); |
544 |
|
return NULL; |
545 |
|
} |
546 |
|
} |
547 |
|
#endif |
548 |
|
nextCPU++; |
549 |
|
/* Infinite loop ends when I've read a chunk for each of the worker nodes plus one more chunk for the master */ |
550 |
|
if (nextCPU > mpi_info->size) break; /* End infinite loop */ |
551 |
|
} /* Infinite loop */ |
552 |
|
} /* End master */ |
553 |
|
else { /* Worker */ |
554 |
|
#ifdef PASO_MPI |
555 |
|
/* Each worker receives one message */ |
556 |
|
MPI_Status status; |
557 |
|
int mpi_error; |
558 |
|
mpi_error = MPI_Recv(tempInts, chunkSize*(2+numNodes)+1, MPI_INT, 0, 81723, mpi_info->comm, &status); |
559 |
|
if ( mpi_error != MPI_SUCCESS ) { |
560 |
|
Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: receive of tempInts for FaceElements failed"); |
561 |
|
return NULL; |
562 |
|
} |
563 |
|
chunkEle = tempInts[chunkSize*(2+numNodes)]; |
564 |
|
#endif |
565 |
|
} /* Worker */ |
566 |
|
|
567 |
|
/* Copy Element data from tempInts to mesh_p */ |
568 |
|
Finley_ElementFile_allocTable(mesh_p->FaceElements, chunkEle); |
569 |
|
mesh_p->FaceElements->minColor=0; |
570 |
|
mesh_p->FaceElements->maxColor=chunkEle-1; |
571 |
|
if (Finley_noError()) { |
572 |
|
#pragma omp parallel for private (i0, i1) |
573 |
|
for (i0=0; i0<chunkEle; i0++) { |
574 |
|
mesh_p->FaceElements->Id[i0] = tempInts[i0*(2+numNodes)+0]; |
575 |
|
mesh_p->FaceElements->Tag[i0] = tempInts[i0*(2+numNodes)+1]; |
576 |
|
mesh_p->FaceElements->Color[i0] = i0; |
577 |
|
for (i1 = 0; i1 < numNodes; i1++) { |
578 |
|
mesh_p->FaceElements->Nodes[INDEX2(i1, i0, numNodes)] = tempInts[i0*(2+numNodes)+2+i1]; |
579 |
|
} |
580 |
|
} |
581 |
|
} |
582 |
|
|
583 |
|
TMPMEMFREE(tempInts); |
584 |
|
} /* end of Read the face element data */ |
585 |
|
|
586 |
|
/* read contact elements */ |
587 |
|
|
588 |
|
/* Read the element typeID */ |
589 |
|
if (Finley_noError()) { |
590 |
|
if (mpi_info->rank == 0) { |
591 |
|
fscanf(fileHandle_p, "%s %d\n", element_type, &numEle); |
592 |
|
typeID=Finley_RefElement_getTypeId(element_type); |
593 |
|
} |
594 |
|
#ifdef PASO_MPI |
595 |
|
if (mpi_info->size > 1) { |
596 |
|
int temp1[2], mpi_error; |
597 |
|
temp1[0] = (int) typeID; |
598 |
|
temp1[1] = numEle; |
599 |
|
mpi_error = MPI_Bcast (temp1, 2, MPI_INT, 0, mpi_info->comm); |
600 |
|
if (mpi_error != MPI_SUCCESS) { |
601 |
|
Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: broadcast of Element typeID failed"); |
602 |
|
return NULL; |
603 |
|
} |
604 |
|
typeID = (ElementTypeId) temp1[0]; |
605 |
|
numEle = temp1[1]; |
606 |
|
} |
607 |
|
#endif |
608 |
|
if (typeID==NoType) { |
609 |
|
sprintf(error_msg, "Finley_Mesh_read: Unidentified element type %s", element_type); |
610 |
|
Finley_setError(VALUE_ERROR, error_msg); |
611 |
|
} |
612 |
|
} |
613 |
|
|
614 |
|
/* Allocate the ElementFile */ |
615 |
|
mesh_p->ContactElements=Finley_ElementFile_alloc(typeID,mesh_p->order, mesh_p->reduced_order, mpi_info); |
616 |
|
numNodes = mesh_p->ContactElements->ReferenceElement->Type->numNodes; /* New meaning for numNodes: num nodes per element */ |
617 |
|
|
618 |
|
/* Read the contact element data */ |
619 |
|
if (Finley_noError()) { |
620 |
|
int chunkSize = numEle / mpi_info->size + 1, totalEle=0, nextCPU=1; |
621 |
|
int *tempInts = TMPMEMALLOC(chunkSize*(2+numNodes)+1, index_t); /* Store Id + Tag + node list (+ one int at end for chunkEle) */ |
622 |
|
/* Elements are specified as a list of integers...only need one message instead of two as with the nodes */ |
623 |
|
if (mpi_info->rank == 0) { /* Master */ |
624 |
|
for (;;) { /* Infinite loop */ |
625 |
|
for (i0=0; i0<chunkSize*(2+numNodes)+1; i0++) tempInts[i0] = -1; |
626 |
|
chunkEle = 0; |
627 |
|
for (i0=0; i0<chunkSize; i0++) { |
628 |
|
if (totalEle >= numEle) break; /* End inner loop */ |
629 |
|
fscanf(fileHandle_p, "%d %d", &tempInts[i0*(2+numNodes)+0], &tempInts[i0*(2+numNodes)+1]); |
630 |
|
for (i1 = 0; i1 < numNodes; i1++) fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]); |
631 |
|
fscanf(fileHandle_p, "\n"); |
632 |
|
totalEle++; |
633 |
|
chunkEle++; |
634 |
|
} |
635 |
|
#ifdef PASO_MPI |
636 |
|
/* Eventually we'll send chunk of elements to each CPU except 0 itself, here goes one of them */ |
637 |
|
if (nextCPU < mpi_info->size) { |
638 |
|
int mpi_error; |
639 |
|
tempInts[chunkSize*(2+numNodes)] = chunkEle; |
640 |
|
mpi_error = MPI_Send(tempInts, chunkSize*(2+numNodes)+1, MPI_INT, nextCPU, 81724, mpi_info->comm); |
641 |
|
if ( mpi_error != MPI_SUCCESS ) { |
642 |
|
Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: send of tempInts for ContactElements failed"); |
643 |
|
return NULL; |
644 |
|
} |
645 |
|
} |
646 |
|
#endif |
647 |
|
nextCPU++; |
648 |
|
/* Infinite loop ends when I've read a chunk for each of the worker nodes plus one more chunk for the master */ |
649 |
|
if (nextCPU > mpi_info->size) break; /* End infinite loop */ |
650 |
|
} /* Infinite loop */ |
651 |
|
} /* End master */ |
652 |
|
else { /* Worker */ |
653 |
|
#ifdef PASO_MPI |
654 |
|
/* Each worker receives one message */ |
655 |
|
MPI_Status status; |
656 |
|
int mpi_error; |
657 |
|
mpi_error = MPI_Recv(tempInts, chunkSize*(2+numNodes)+1, MPI_INT, 0, 81724, mpi_info->comm, &status); |
658 |
|
if ( mpi_error != MPI_SUCCESS ) { |
659 |
|
Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: receive of tempInts for ContactElements failed"); |
660 |
|
return NULL; |
661 |
|
} |
662 |
|
chunkEle = tempInts[chunkSize*(2+numNodes)]; |
663 |
|
#endif |
664 |
|
} /* Worker */ |
665 |
|
|
666 |
|
/* Copy Element data from tempInts to mesh_p */ |
667 |
|
Finley_ElementFile_allocTable(mesh_p->ContactElements, chunkEle); |
668 |
|
mesh_p->ContactElements->minColor=0; |
669 |
|
mesh_p->ContactElements->maxColor=chunkEle-1; |
670 |
|
if (Finley_noError()) { |
671 |
|
#pragma omp parallel for private (i0, i1) |
672 |
|
for (i0=0; i0<chunkEle; i0++) { |
673 |
|
mesh_p->ContactElements->Id[i0] = tempInts[i0*(2+numNodes)+0]; |
674 |
|
mesh_p->ContactElements->Tag[i0] = tempInts[i0*(2+numNodes)+1]; |
675 |
|
mesh_p->ContactElements->Color[i0] = i0; |
676 |
|
for (i1 = 0; i1 < numNodes; i1++) { |
677 |
|
mesh_p->ContactElements->Nodes[INDEX2(i1, i0, numNodes)] = tempInts[i0*(2+numNodes)+2+i1]; |
678 |
|
} |
679 |
|
} |
680 |
|
} |
681 |
|
|
682 |
|
TMPMEMFREE(tempInts); |
683 |
|
} /* end of Read the contact element data */ |
684 |
|
|
685 |
|
/* read nodal elements */ |
686 |
|
|
687 |
|
/* Read the element typeID */ |
688 |
|
if (Finley_noError()) { |
689 |
|
if (mpi_info->rank == 0) { |
690 |
|
fscanf(fileHandle_p, "%s %d\n", element_type, &numEle); |
691 |
|
typeID=Finley_RefElement_getTypeId(element_type); |
692 |
|
} |
693 |
|
#ifdef PASO_MPI |
694 |
|
if (mpi_info->size > 1) { |
695 |
|
int temp1[2], mpi_error; |
696 |
|
temp1[0] = (int) typeID; |
697 |
|
temp1[1] = numEle; |
698 |
|
mpi_error = MPI_Bcast (temp1, 2, MPI_INT, 0, mpi_info->comm); |
699 |
|
if (mpi_error != MPI_SUCCESS) { |
700 |
|
Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: broadcast of Element typeID failed"); |
701 |
|
return NULL; |
702 |
|
} |
703 |
|
typeID = (ElementTypeId) temp1[0]; |
704 |
|
numEle = temp1[1]; |
705 |
|
} |
706 |
|
#endif |
707 |
|
if (typeID==NoType) { |
708 |
|
sprintf(error_msg, "Finley_Mesh_read: Unidentified element type %s", element_type); |
709 |
|
Finley_setError(VALUE_ERROR, error_msg); |
710 |
|
} |
711 |
|
} |
712 |
|
|
713 |
|
/* Allocate the ElementFile */ |
714 |
|
mesh_p->Points=Finley_ElementFile_alloc(typeID,mesh_p->order, mesh_p->reduced_order, mpi_info); |
715 |
|
numNodes = mesh_p->Points->ReferenceElement->Type->numNodes; /* New meaning for numNodes: num nodes per element */ |
716 |
|
|
717 |
|
/* Read the nodal element data */ |
718 |
|
if (Finley_noError()) { |
719 |
|
int chunkSize = numEle / mpi_info->size + 1, totalEle=0, nextCPU=1; |
720 |
|
int *tempInts = TMPMEMALLOC(chunkSize*(2+numNodes)+1, index_t); /* Store Id + Tag + node list (+ one int at end for chunkEle) */ |
721 |
|
/* Elements are specified as a list of integers...only need one message instead of two as with the nodes */ |
722 |
|
if (mpi_info->rank == 0) { /* Master */ |
723 |
|
for (;;) { /* Infinite loop */ |
724 |
|
for (i0=0; i0<chunkSize*(2+numNodes)+1; i0++) tempInts[i0] = -1; |
725 |
|
chunkEle = 0; |
726 |
|
for (i0=0; i0<chunkSize; i0++) { |
727 |
|
if (totalEle >= numEle) break; /* End inner loop */ |
728 |
|
fscanf(fileHandle_p, "%d %d", &tempInts[i0*(2+numNodes)+0], &tempInts[i0*(2+numNodes)+1]); |
729 |
|
for (i1 = 0; i1 < numNodes; i1++) fscanf(fileHandle_p, " %d", &tempInts[i0*(2+numNodes)+2+i1]); |
730 |
|
fscanf(fileHandle_p, "\n"); |
731 |
|
totalEle++; |
732 |
|
chunkEle++; |
733 |
|
} |
734 |
|
#ifdef PASO_MPI |
735 |
|
/* Eventually we'll send chunk of elements to each CPU except 0 itself, here goes one of them */ |
736 |
|
if (nextCPU < mpi_info->size) { |
737 |
|
int mpi_error; |
738 |
|
tempInts[chunkSize*(2+numNodes)] = chunkEle; |
739 |
|
mpi_error = MPI_Send(tempInts, chunkSize*(2+numNodes)+1, MPI_INT, nextCPU, 81725, mpi_info->comm); |
740 |
|
if ( mpi_error != MPI_SUCCESS ) { |
741 |
|
Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: send of tempInts for Points failed"); |
742 |
|
return NULL; |
743 |
|
} |
744 |
|
} |
745 |
|
#endif |
746 |
|
nextCPU++; |
747 |
|
/* Infinite loop ends when I've read a chunk for each of the worker nodes plus one more chunk for the master */ |
748 |
|
if (nextCPU > mpi_info->size) break; /* End infinite loop */ |
749 |
|
} /* Infinite loop */ |
750 |
|
} /* End master */ |
751 |
|
else { /* Worker */ |
752 |
|
#ifdef PASO_MPI |
753 |
|
/* Each worker receives one message */ |
754 |
|
MPI_Status status; |
755 |
|
int mpi_error; |
756 |
|
mpi_error = MPI_Recv(tempInts, chunkSize*(2+numNodes)+1, MPI_INT, 0, 81725, mpi_info->comm, &status); |
757 |
|
if ( mpi_error != MPI_SUCCESS ) { |
758 |
|
Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: receive of tempInts for Points failed"); |
759 |
|
return NULL; |
760 |
|
} |
761 |
|
chunkEle = tempInts[chunkSize*(2+numNodes)]; |
762 |
|
#endif |
763 |
|
} /* Worker */ |
764 |
|
|
765 |
|
/* Copy Element data from tempInts to mesh_p */ |
766 |
|
Finley_ElementFile_allocTable(mesh_p->Points, chunkEle); |
767 |
|
mesh_p->Points->minColor=0; |
768 |
|
mesh_p->Points->maxColor=chunkEle-1; |
769 |
|
if (Finley_noError()) { |
770 |
|
#pragma omp parallel for private (i0, i1) |
771 |
|
for (i0=0; i0<chunkEle; i0++) { |
772 |
|
mesh_p->Points->Id[i0] = tempInts[i0*(2+numNodes)+0]; |
773 |
|
mesh_p->Points->Tag[i0] = tempInts[i0*(2+numNodes)+1]; |
774 |
|
mesh_p->Points->Color[i0] = i0; |
775 |
|
for (i1 = 0; i1 < numNodes; i1++) { |
776 |
|
mesh_p->Points->Nodes[INDEX2(i1, i0, numNodes)] = tempInts[i0*(2+numNodes)+2+i1]; |
777 |
|
} |
778 |
|
} |
779 |
|
} |
780 |
|
|
781 |
|
TMPMEMFREE(tempInts); |
782 |
|
} /* end of Read the nodal element data */ |
783 |
|
|
784 |
|
/* ksteube TODO: read tags */ |
785 |
|
|
786 |
} |
} |
787 |
|
|
788 |
/* close file */ |
/* close file */ |
791 |
/* resolve id's : */ |
/* resolve id's : */ |
792 |
/* rearrange elements: */ |
/* rearrange elements: */ |
793 |
|
|
794 |
return mesh_p; /* ksteube temp return for debugging */ |
/* return mesh_p; */ /* ksteube temp return for debugging */ |
795 |
|
|
796 |
if (Finley_noError()) Finley_Mesh_resolveNodeIds(mesh_p); |
if (Finley_noError()) Finley_Mesh_resolveNodeIds(mesh_p); |
797 |
if (Finley_noError()) Finley_Mesh_prepare(mesh_p, optimize); |
if (Finley_noError()) Finley_Mesh_prepare(mesh_p, optimize); |