/[escript]/trunk/finley/src/Mesh_read.c
ViewVC logotype

Diff of /trunk/finley/src/Mesh_read.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1725 by ksteube, Tue Aug 26 03:31:49 2008 UTC revision 1732 by ksteube, Wed Aug 27 05:47:03 2008 UTC
# Line 308  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 308  Finley_Mesh* Finley_Mesh_read_MPI(char*
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],
# Line 343  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 343  Finley_Mesh* Finley_Mesh_read_MPI(char*
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 */
# Line 368  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 369  Finley_Mesh* Finley_Mesh_read_MPI(char*
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()) {
# Line 427  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 413  Finley_Mesh* Finley_Mesh_read_MPI(char*
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) */
# Line 440  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 427  Finley_Mesh* Finley_Mesh_read_MPI(char*
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");
# Line 457  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 444  Finley_Mesh* Finley_Mesh_read_MPI(char*
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 */
# Line 477  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 465  Finley_Mesh* Finley_Mesh_read_MPI(char*
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;
# Line 502  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 482  Finley_Mesh* Finley_Mesh_read_MPI(char*
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 */
# Line 511  Finley_Mesh* Finley_Mesh_read_MPI(char* Line 791  Finley_Mesh* Finley_Mesh_read_MPI(char*
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);

Legend:
Removed from v.1725  
changed lines
  Added in v.1732

  ViewVC Help
Powered by ViewVC 1.1.26