gmvread.c

一个用来实现偏微分方程中网格的计算库

                 {
                  lxic[i] = tmpfloat[i];
                  lyic[i] = tmpfloat[lnodes+i];
                  lzic[i] = tmpfloat[2*lnodes+i];
                 }
              }
            if (node_inp_type == 1)  /*  nodev type  */
              {
               for (i = 0; i < lnodes; i++)
                 {
                  lxic[i] = tmpfloat[3*i];
                  lyic[i] = tmpfloat[3*i+1];
                  lzic[i] = tmpfloat[3*i+2];
                 }
              }
            FREE(tmpfloat);
           }
        }
      if (ftype == ASCII)
        {
         tmpdouble = (double *)malloc((3*lnodes)*sizeof(double));
         if (tmpdouble == NULL)
              {
               gmvrdmemerr();
               return;
              }
         rdfloats(tmpdouble,3*lnodes,gmvin);
         if (node_inp_type == 0)  /*  nodes type  */
           {
            for (i = 0; i < lnodes; i++)
              {
               lxic[i] = tmpdouble[i];
               lyic[i] = tmpdouble[lnodes+i];
               lzic[i] = tmpdouble[2*lnodes+i];
              }
           }
         if (node_inp_type == 1)  /*  nodev type  */
           {
            for (i = 0; i < lnodes; i++)
              {
               lxic[i] = tmpdouble[3*i];
               lyic[i] = tmpdouble[3*i+1];
               lzic[i] = tmpdouble[3*i+2];
              }
           }
         FREE(tmpdouble);
        }
     }

   if (lstructuredflag == 1)
     {
      lxic = (double *)malloc((lnxv)*sizeof(double));
      lyic = (double *)malloc((lnyv)*sizeof(double));
      lzic = (double *)malloc((lnzv)*sizeof(double));
      if (lxic == NULL || lyic == NULL || lzic == NULL)
        {
         gmvrdmemerr();
         return;
        }
      if (ftype != ASCII)
        {
         if (ftype == IEEEI4R8 || ftype == IEEEI8R8)
           {
            binread(lxic,doublesize,DOUBLE,(long)lnxv,gmvin);
            ioerrtst(gmvin);
            binread(lyic,doublesize,DOUBLE,(long)lnyv,gmvin);
            ioerrtst(gmvin);
            binread(lzic,doublesize,DOUBLE,(long)lnzv,gmvin);
            ioerrtst(gmvin);
           }
         else
           {
            k = (lnxv > lnyv) ? lnxv : lnyv;
            k = (k > lnzv) ? k : lnzv;
            tmpfloat = (float *)malloc((k)*sizeof(float));
            if (tmpfloat == NULL)
              {
               gmvrdmemerr();
               return;
              }
            binread(tmpfloat,floatsize,FLOAT,(long)lnxv,gmvin);
            ioerrtst(gmvin);
            for (i = 0; i < lnxv; i++) lxic[i] = tmpfloat[i];
            binread(tmpfloat,floatsize,FLOAT,(long)lnyv,gmvin);
            ioerrtst(gmvin);
            for (i = 0; i < lnyv; i++) lyic[i] = tmpfloat[i];
            binread(tmpfloat,floatsize,FLOAT,(long)lnzv,gmvin);
            ioerrtst(gmvin);
            for (i = 0; i < lnzv; i++) lzic[i] = tmpfloat[i];
            free(tmpfloat);
           }
        }
      if (ftype == ASCII)
        {
         rdfloats(lxic,(long)lnxv,gmvin);
         rdfloats(lyic,(long)lnyv,gmvin);
         rdfloats(lzic,(long)lnzv,gmvin);
        }
     }

   if ((feof(gmvin) != 0) | (ferror(gmvin) != 0))
     {
      fprintf(stderr,"I/O error while reading nodes.\n");
      gmv_data.keyword = GMVERROR;
      return;
     }

   if (!skipflag)
     {
      numnodes = lnodes;
      nodes_read = 1;
     }

   if (amrflag_in == 0) 
     {
      gmv_data.keyword = NODES;
      if (lstructuredflag == 0) gmv_data.datatype = UNSTRUCT;
      if (lstructuredflag == 1) gmv_data.datatype = STRUCT;
      if (lstructuredflag == 2) gmv_data.datatype = LOGICALLY_STRUCT;
      gmv_data.num = lnodes;
      gmv_data.num2 = NODES;
      if (node_inp_type == 1) gmv_data.num2 = NODE_V;
      if (lstructuredflag == 1 || lstructuredflag == 2)
        {
         gmv_data.ndoubledata1 = lnxv;
         gmv_data.doubledata1 = lxic;
         gmv_data.ndoubledata2 = lnyv;
         gmv_data.doubledata2 = lyic;
         gmv_data.ndoubledata3 = lnzv;
         gmv_data.doubledata3 = lzic;
         ncells_struct = (lnxv-1) * (lnyv-1) * (lnzv-1);
         if (lnzv == 1) ncells_struct = (lnxv-1) * (lnyv-1);
        }
      else
        {
         gmv_data.ndoubledata1 = lnodes;
         gmv_data.doubledata1 = lxic;
         gmv_data.ndoubledata2 = lnodes;
         gmv_data.doubledata2 = lyic;
         gmv_data.ndoubledata3 = lnodes;
         gmv_data.doubledata3 = lzic;
        }
     }
}


void readcells(FILE* gmvin, int ftype)
{
  int i, ndat, nverts[1000], totverts, *verts,
      *cellnodenos, nfaces;
  long *lfaces, numtop, *daughters;
  long *lcellnodenos;
  char keyword[9];

   if (readkeyword == 1)
     {
      numcellsin = 0;
      if (ftype == ASCII)
        {
         fscanf(gmvin,"%ld",&lncells);
         ioerrtst(gmvin);
        }
      else
        {
         if (ftype == IEEEI8R4 || ftype == IEEEI8R8)
           {         
            binread(&lncells,longlongsize,LONGLONG,(long)1,gmvin);
           }
         else
           {         
            binread(&i,intsize,INT,(long)1,gmvin);
            lncells = i;
           }
        }

      if (printon)
         printf("Reading %ld cells.\n",lncells);

      if (!skipflag)
        {
         numcells = lncells;
         cells_read = 1;
        }
     }

   /*  If amr, read numtop and daughter list.  */
   if (amrflag_in)
     {
      if (ftype == ASCII)
        {
         fscanf(gmvin,"%ld",&numtop);
         ioerrtst(gmvin);
        }
      else
        {
         if (ftype == IEEEI8R4 || ftype == IEEEI8R8)
           {         
            binread(&numtop,longlongsize,LONGLONG,(long)1,gmvin);
           }
         else
           {         
            binread(&i,intsize,INT,(long)1,gmvin);
            numtop = i;
           }
        }

      daughters = (long *)malloc(lncells*sizeof(long));
      if (daughters == NULL)
        {
         gmvrdmemerr();
         return;
        }
      if (ftype != ASCII)
        {
         if (ftype == IEEEI4R4 || ftype == IEEEI4R8)
           {
            cellnodenos = (int *)malloc(lncells*sizeof(int));
            if (cellnodenos == NULL)
              {
               gmvrdmemerr();
               return;
              }
            binread(cellnodenos,intsize,INT,lncells,gmvin);
            ioerrtst(gmvin);
            for (i = 0; i < lncells; i++)
              daughters[i] = cellnodenos[i];
            FREE(cellnodenos);
           }
         else
           {
            binread(daughters,longlongsize,LONGLONG,lncells,gmvin);
            ioerrtst(gmvin);
           }
        }
      if (ftype == ASCII) rdlongs(daughters,lncells,gmvin);

      gmv_data.keyword = CELLS;
      gmv_data.datatype = AMR;
      gmv_data.num = lncells;
      gmv_data.num2 = numtop;
      gmv_data.nlongdata1 = lncells;
      gmv_data.longdata1 = daughters;
      numcells = numtop;
      readkeyword = 1;
      return;      
     }

   /*  See if all cells read.  */
   numcellsin++;
   if (numcellsin > lncells)
     {
      readkeyword = 2;
      if (numcells == 0) readkeyword = 1;

      /*  If structured mesh, reset numcells.  */
      if (structflag_in == 1) numcells = ncells_struct;
      gmv_data.keyword = CELLS;
      gmv_data.datatype = ENDKEYWORD;
      gmv_data.num = numcells;
      return;
     }

   /*  Read a cell at at time.  */
   if (ftype != ASCII)
     {
      binread(keyword,charsize,CHAR,(long)8,gmvin);
      *(keyword+8)=(char)0;
      binread(&ndat,intsize,INT,(long)1,gmvin);
      ioerrtst(gmvin);
     }
   if (ftype == ASCII) fscanf(gmvin,"%s%d",keyword,&ndat);

   /*  Check cell type.  */
   if (strncmp(keyword,"general",7) != 0 &&
       strncmp(keyword,"line",4) != 0 &&
       strncmp(keyword,"tri",3) != 0 &&
       strncmp(keyword,"quad",4) != 0 &&
       strncmp(keyword,"tet",3) != 0 &&
       strncmp(keyword,"hex",3) != 0 &&
       strncmp(keyword,"prism",5) != 0 &&
       strncmp(keyword,"pyramid",7) != 0 &&
       strncmp(keyword,"vface2d",7) != 0 &&
       strncmp(keyword,"vface3d",7) != 0 &&
       strncmp(keyword,"phex8",5) != 0 &&
       strncmp(keyword,"phex20",6) != 0 &&
       strncmp(keyword,"phex27",6) != 0 &&
       strncmp(keyword,"ppyrmd5",7) != 0 &&
       strncmp(keyword,"ppyrmd13",8) != 0 &&
       strncmp(keyword,"pprism6",7) != 0 &&
       strncmp(keyword,"pprism15",8) != 0 &&
       strncmp(keyword,"ptet4",5) != 0 &&
       strncmp(keyword,"ptet10",6) != 0 &&
       strncmp(keyword,"6tri",4) != 0 &&
       strncmp(keyword,"8quad",5) != 0 &&
       strncmp(keyword,"3line",5) != 0)
     {
      fprintf(stderr,
              "Error, %s is an invalid cell type.\n",keyword);
      gmv_data.keyword = GMVERROR;
      return;
     }
   if ((strncmp(keyword,"line",4) == 0 && ndat != 2) ||
       (strncmp(keyword,"tri",3) == 0 && ndat != 3) ||
       (strncmp(keyword,"quad",4) == 0 && ndat != 4) ||
       (strncmp(keyword,"tet",3) == 0 && ndat != 4) ||
       (strncmp(keyword,"hex",3) == 0 && ndat != 8) ||
       (strncmp(keyword,"prism",5) == 0 && ndat != 6) ||
       (strncmp(keyword,"pyramid",7) == 0 && ndat != 5) ||
       (strncmp(keyword,"phex8",5) == 0 && ndat != 8) ||
       (strncmp(keyword,"phex20",6) == 0 && ndat != 20) ||
       (strncmp(keyword,"phex27",6) == 0 && ndat != 27) ||
       (strncmp(keyword,"ppyrmd5",7) == 0 && ndat != 5) ||
       (strncmp(keyword,"ppyrmd13",8) == 0 && ndat != 13) ||
       (strncmp(keyword,"pprism6",7) == 0 && ndat != 6) ||
       (strncmp(keyword,"pprism15",8) == 0 && ndat != 15) ||
       (strncmp(keyword,"ptet4",5) == 0 && ndat != 4) ||
       (strncmp(keyword,"ptet10",6) == 0 && ndat != 10) ||
       (strncmp(keyword,"6tri",4) == 0 && ndat != 6) ||
       (strncmp(keyword,"8quad",5) == 0 && ndat != 8) ||
       (strncmp(keyword,"3line",5) == 0 && ndat != 3))
     {
      fprintf(stderr,
              "Error, %d nodes is invalid for a %s.\n",ndat,keyword);
      gmv_data.keyword = GMVERROR;
      return;
     }

   if ((feof(gmvin) != 0) | (ferror(gmvin) != 0))
     {
      fprintf(stderr,"I/O error while reading cells.\n");
      gmv_data.keyword = GMVERROR;
      return;
     }

   /*  At first cell, set vfaceflag.  */
   if (readkeyword == 1)
     {
      vfaceflag = 0;
      if (strncmp(keyword,"vface2d",7) == 0) vfaceflag = 2;
      if (strncmp(keyword,"vface3d",7) == 0) vfaceflag = 3;
     }

   /*  After first cell, check for vface consistency.  */
   if (readkeyword == 0)
     {
      if ((vfaceflag == 0 && strncmp(keyword,"vface",5) == 0) ||
          (vfaceflag > 0 && strncmp(keyword,"vface",5) != 0))
        {
         fprintf(stderr,
           "Error, cannot mix vface2d or vface3d with other cell types.\n");
         gmv_data.keyword = GMVERROR;
         return;
        }
      if ((vfaceflag == 2 && strncmp(keyword,"vface3d",7) == 0) ||
          (vfaceflag == 3 && strncmp(keyword,"vface2d",7) == 0))
        {
         fprintf(stderr,
           "Error, cannot mix vface2d and vface3d cell types.\n");
         gmv_data.keyword = GMVERROR;
         return;
        }
     }

   /*  Read general cell data.  */
   if (strncmp(keyword,"general",7) == 0)
     {

      /*  Read no. of vertices per face.  */
      nfaces = ndat;
      if (nfaces > 1000)
        {
         fprintf(stderr,
                  "Error, Read %d faces - 1000 faces per cell allowed.\n",
                   nfaces);
         gmv_data.keyword = GMVERROR;
         return;
        }
      if (ftype != ASCII) binread(nverts,intsize,INT,(long)nfaces,gmvin);
      if (ftype == ASCII) rdints(nverts,nfaces,gmvin);
      ioerrtst(gmvin);

      /*  Read all face vertices, reallocate if needed.  */
      totverts = 0;
      for (i = 0; i < nfaces; i++) totverts += nverts[i];
      lcellnodenos = (long *)malloc(totverts*sizeof(long));
      if (lcellnodenos == NULL)
        {
         gmvrdmemerr();
         return;
        }
      if (ftype != ASCII)
        {
         if (ftype == IEEEI4R4 || ftype == IEEEI4R8)
           {
            cellnodenos = (int *)malloc(totverts*sizeof(int));
            if (cellnodenos == NULL)
              {
               gmvrdmemerr();
               return;
              }
            binread(cellnodenos,intsize,INT,(long)totverts,gmvin);
            for (i = 0; i < totverts; i++)
              lcellnodenos[i] = cellnodenos[i];
            FREE(cellnodenos);
           }
         else
            binread(lcellnodenos,longlongsize,LONGLONG, 
                    (long)totverts,gmvin);
         ioerrtst(gmvin);
        }
      if (ftype == ASCII) rdlongs(lcellnodenos,(long)totverts,gmvin);
      lfaces = (long *)malloc(nfaces*sizeof(long));
      if (lfaces == NULL)
        {
         gmvrdmemerr();
         return;
        }
      for (i = 0; i < nfaces; i++)
        lfaces[i] = nverts[i];

      gmv_data.keyword = CELLS;
      gmv_data.datatype = GENERAL;
      strcpy(gmv_data.name1,keyword);
      gmv_data.num = lncells;
      gmv_data.num2 = nfaces;
      gmv_data.nlongdata1 = nfaces;
      gmv_data.longdata1 = lfaces;
      gmv_data.nlongdata2 = totverts;
      gmv_data.longdata2 = lcellnodenos;
     }

   /*  Else read vface2d or vface3d data.  */
   else if (strncmp(keyword,"vface2d",7) == 0 ||
            strncmp(keyword,"vface3d",7) == 0)
     {

      /*  Check no. of  faces.  */
      nfaces = ndat;
      if (nfaces > 1000)
        {
         fprintf(stderr,
                  "Error, Read %d faces - 1000 faces per cell allowed.\n",
                   nfaces);
         gmv_data.keyword = GMVERROR;