freemsh2.c

来自「算断裂的」· C语言 代码 · 共 259 行

/*
// ------------------------------------------------------------------
// freemsh2.c
//
// This file contains the function for deleting a mesh.
// ------------------------------------------------------------------
// Author: Stephen A. Vavasis
// Copyright (c) 1998 by Cornell University.  All rights reserved.
// 
// See the accompanying file 'Copyright' for authorship information,
// the terms of the license governing this software, and disclaimers
// concerning this software.
// ------------------------------------------------------------------
// This file is part of the CPTC and QMG software.  
// Version 2.0 of QMG, release date RELDATE.
// ------------------------------------------------------------------
*/

#include <stdlib.h>
#include "MshFmt2.h"
#include <string.h>

void cptc_free_mesh(mesh)
Cptc_MshDesc* mesh;
{
  int i;
  if (mesh == 0) return;
  for (i = 0; i < mesh -> num_prop_val; ++i) {
    free(mesh -> props[i]);
    free(mesh -> vals[i]);
  }
  if (mesh -> props)
    free(mesh -> props);
  if (mesh -> vals)
    free(mesh -> vals);
  if (mesh -> nodes) 
    free(mesh -> nodes);
  if (mesh -> vtxinfo)
    free(mesh -> vtxinfo);
  for (i = 0; i < mesh -> num_top_edges; ++i) {
    if (mesh -> edgeinfo[i].incs)
      free(mesh -> edgeinfo[i].incs);
    if (mesh -> edgeinfo[i].edgelist)
      free(mesh -> edgeinfo[i].edgelist);
  }
  if (mesh -> edgeinfo) {
    free(mesh -> edgeinfo);
  }
  for (i = 0; i < mesh -> num_top_surfaces; ++i) {
    if (mesh -> surfinfo[i].incs)
      free(mesh -> surfinfo[i].incs);
    if (mesh -> surfinfo[i].trifacetlist)
      free(mesh -> surfinfo[i].trifacetlist);
    if (mesh -> surfinfo[i].quadfacetlist)
      free(mesh -> surfinfo[i].quadfacetlist);
  }
  if (mesh -> surfinfo) {
    free(mesh -> surfinfo);
  }
  for (i = 0; i < mesh -> num_top_regions; ++i) {
    if (mesh -> regioninfo[i].tets)
      free(mesh -> regioninfo[i].tets);
    if (mesh -> regioninfo[i].pyramids)
      free(mesh -> regioninfo[i].pyramids);
    if (mesh -> regioninfo[i].prisms)
      free(mesh -> regioninfo[i].prisms);
    if (mesh -> regioninfo[i].hexs)
      free(mesh -> regioninfo[i].hexs);
  };

  if (mesh -> regioninfo)
    free(mesh -> regioninfo);
  free(mesh);
}




/* clone a string */

static void clone_id(dest, src)
char**dest;
char* src;
{
  *dest = (char*) malloc(strlen(src) + 1);
  strcpy(*dest, src);
}

/* clone a property-value list */

static void clone_prop_vals(destnumprops, destprops,  destvals,
                            numprop, srcprops, srcvals) 
int* destnumprops;
char*** destprops; 
char*** destvals;
int numprop;
char** srcprops;
char** srcvals;
{
  int i;
  *destprops = (char**) malloc(numprop * sizeof(char*));
  *destvals = (char**) malloc(numprop * sizeof(char*));
  *destnumprops = numprop;
  for (i = 0; i < numprop; ++i) {
    clone_id(&((*destprops)[i]), srcprops[i]);
    clone_id(&((*destvals)[i]), srcvals[i]);
  }
}
 

typedef Cptc_Global_Node Cptc_freemesh2_c_int2[2];
typedef Cptc_Global_Node Cptc_freemesh2_c_int3[3];
typedef Cptc_Global_Node Cptc_freemesh2_c_int4[4];
typedef Cptc_Global_Node Cptc_freemesh2_c_int5[5];
typedef Cptc_Global_Node Cptc_freemesh2_c_int6[6];
typedef Cptc_Global_Node Cptc_freemesh2_c_int8[8];

/* clone an entire mesh */

Cptc_MshDesc* cptc_clone_mesh(mesh)
Cptc_MshDesc* mesh;
{
  int i, j, k, nn, nte, nmn, nmf, gdim;
  Cptc_MshDesc* newmesh;
  if (mesh == 0) return 0;
  gdim = mesh -> intrinsic_dimension;
  newmesh = (Cptc_MshDesc*) malloc(sizeof(Cptc_MshDesc));
  *newmesh = *mesh;
  clone_prop_vals(&(newmesh -> num_prop_val), &(newmesh -> props),
    &(newmesh -> vals), mesh -> num_prop_val, mesh -> props, mesh -> vals);
  nn = mesh -> num_nodes;
  newmesh -> nodes = (Cptc_Mnode*) malloc(sizeof(Cptc_Mnode) * nn);
  for (i = 0; i < nn; ++i)
    newmesh -> nodes[i] = mesh -> nodes[i];
  if (gdim >= 0) {
    nte = mesh -> num_top_vertices;
    newmesh -> vtxinfo = (Cptc_MeshTopVertexInfo*) malloc(sizeof(Cptc_MeshTopVertexInfo) * nte);
    for (i = 0; i < nte; ++i)
      newmesh -> vtxinfo[i] = mesh -> vtxinfo[i];
  }
  else {
    newmesh -> vtxinfo = 0;
  }
  if (gdim >= 1) {
    nte = mesh -> num_top_edges;
    newmesh -> edgeinfo = (Cptc_MeshTopEdgeInfo*) malloc(sizeof(Cptc_MeshTopEdgeInfo) * nte);
    for (i = 0; i < nte; ++i) {
      nmn = mesh -> edgeinfo[i].num_mnode;
      newmesh -> edgeinfo[i].num_mnode = nmn;
      newmesh -> edgeinfo[i].incs = (Cptc_NodeCurveInc*) malloc(sizeof(Cptc_NodeCurveInc) * nmn);
      for (j = 0; j < nmn; ++j) {
        newmesh -> edgeinfo[i].incs[j] = mesh -> edgeinfo[i].incs[j];
      }
      nmf = mesh -> edgeinfo[i].num_medge;
      newmesh -> edgeinfo[i].num_medge = nmf;
      newmesh -> edgeinfo[i].edgelist = (Cptc_freemesh2_c_int2*)
        malloc(sizeof(Cptc_freemesh2_c_int2) * nmf);
      for (j = 0; j < nmf; ++j) {
        for (k = 0; k < 2; ++k) {
          newmesh -> edgeinfo[i].edgelist[j][k] =
            mesh -> edgeinfo[i].edgelist[j][k];
        }
      }
    }
  }
  else {
    newmesh -> edgeinfo = 0;
  }

  if (gdim >= 2) {
    nte = mesh -> num_top_surfaces;
    newmesh -> surfinfo = (Cptc_MeshTopSurfaceInfo*) 
      malloc(sizeof(Cptc_MeshTopSurfaceInfo) * nte);
    for (i = 0; i < nte; ++i) {
      nmn = mesh -> surfinfo[i].num_mnode;
      newmesh -> surfinfo[i].num_mnode = nmn;
      newmesh -> surfinfo[i].incs = (Cptc_NodePatchInc*) malloc(sizeof(Cptc_NodePatchInc) * nmn);
      for (j = 0; j < nmn; ++j) {
        newmesh -> surfinfo[i].incs[j] = mesh -> surfinfo[i].incs[j];
      }
      nmf = mesh -> surfinfo[i].num_mtrifacet;
      newmesh -> surfinfo[i].num_mtrifacet = nmf;
      newmesh -> surfinfo[i].trifacetlist = (Cptc_freemesh2_c_int3*)
        malloc(sizeof(Cptc_freemesh2_c_int3) * nmf);
      for (j = 0; j < nmf; ++j) {
        for (k = 0; k < 3; ++k) {
          newmesh -> surfinfo[i].trifacetlist[j][k] = 
            mesh -> surfinfo[i].trifacetlist[j][k];
        }
      }
      nmf = mesh -> surfinfo[i].num_mquadfacet;
      newmesh -> surfinfo[i].num_mquadfacet = nmf;
      newmesh -> surfinfo[i].quadfacetlist = (Cptc_freemesh2_c_int4*)
        malloc(sizeof(Cptc_freemesh2_c_int4) * nmf);
      for (j = 0; j < nmf; ++j) {
        for (k = 0; k < 4; ++k) {
          newmesh -> surfinfo[i].quadfacetlist[j][k] = 
            mesh -> surfinfo[i].quadfacetlist[j][k];
        }
      }      
    }
  }
  else {
    newmesh -> surfinfo = 0;
  }

  if (gdim >= 3) {
    nte = mesh -> num_top_regions;
    newmesh -> regioninfo = (Cptc_MeshTopRegionInfo*) malloc(sizeof(Cptc_MeshTopRegionInfo) * nte);
    for (i = 0; i < nte; ++i) {
      nmf = mesh -> regioninfo[i].num_tet;
      newmesh -> regioninfo[i].num_tet = nmf;
      newmesh -> regioninfo[i].tets = (Cptc_freemesh2_c_int4*)
        malloc(sizeof(Cptc_freemesh2_c_int4) * nmf);
      for (j = 0; j < nmf; ++j) {
        for (k = 0; k < 4; ++k) {
          newmesh -> regioninfo[i].tets[j][k] = 
            mesh -> regioninfo[i].tets[j][k];
        }
      }      
      nmf = mesh -> regioninfo[i].num_pyramid;
      newmesh -> regioninfo[i].num_pyramid = nmf;
      newmesh -> regioninfo[i].pyramids = (Cptc_freemesh2_c_int5*)
        malloc(sizeof(Cptc_freemesh2_c_int5) * nmf);
      for (j = 0; j < nmf; ++j) {
        for (k = 0; k < 5; ++k) {
          newmesh -> regioninfo[i].pyramids[j][k] = 
            mesh -> regioninfo[i].pyramids[j][k];
        }
      }      
      nmf = mesh -> regioninfo[i].num_prism;
      newmesh -> regioninfo[i].num_prism = nmf;
      newmesh -> regioninfo[i].prisms = (Cptc_freemesh2_c_int6*)
        malloc(sizeof(Cptc_freemesh2_c_int6) * nmf);
      for (j = 0; j < nmf; ++j) {
        for (k = 0; k < 6; ++k) {
          newmesh -> regioninfo[i].prisms[j][k] = 
            mesh -> regioninfo[i].prisms[j][k];
        }
      }      
      nmf = mesh -> regioninfo[i].num_hex;
      newmesh -> regioninfo[i].num_hex = nmf;
      newmesh -> regioninfo[i].hexs = (Cptc_freemesh2_c_int8*)
        malloc(sizeof(Cptc_freemesh2_c_int8) * nmf);
      for (j = 0; j < nmf; ++j) {
        for (k = 0; k < 8; ++k) {
          newmesh -> regioninfo[i].hexs[j][k] = 
            mesh -> regioninfo[i].hexs[j][k];
        }
      }      
    }
  }
  else {
    newmesh -> regioninfo = 0;
  }
  return newmesh;
}