Changeset 471:871f56e7ce10


Ignore:
Timestamp:
02/17/11 15:00:19 (4 years ago)
Author:
Rao Garimella <rao@…>
Branch:
default
Message:

Updated to include parallel mesh management functionality

Location:
include
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • include/MEdge.h

    r422 r471  
    8484  int ME_IsLocked(MEdge_ptr e);
    8585
     86#ifdef MSTK_HAVE_MPI
     87 /*for mpi*/
     88  PType ME_PType(MEdge_ptr e);
     89  void  ME_Set_PType(MEdge_ptr e, PType ptype);
     90  int   ME_MasterParID(MEdge_ptr e);
     91  void  ME_Set_MasterParID(MEdge_ptr e, int masterparid);
     92  int   ME_GlobalID(MEdge_ptr e);
     93  void  ME_Set_GlobalID(MEdge_ptr e, int globalid);
     94  MEdge_ptr ME_GhostNew(Mesh_ptr mesh);
     95  /*end for mpi*/
     96#endif
     97
    8698#ifdef __cplusplus
    8799}
  • include/MEntity.h

    r357 r471  
    1717    unsigned int marker;
    1818    List_ptr AttInsList;
     19
     20#ifdef MSTK_HAVE_MPI
     21    /*for mpi*/
     22    unsigned int ptype_masterparid;
     23    unsigned int globalid;
     24    /*end for mpi*/
     25#endif
     26
    1927  } MEntity_Data, *MEntity_Data_ptr;
    2028
     
    2533#else
    2634  typedef void *MEntity_ptr;
     35#endif
     36
     37#ifdef MSTK_HAVE_MPI
     38  /*for mpi*/
     39  PType MEnt_PType(MEntity_ptr ent);
     40  void  MEnt_Set_PType(MEntity_ptr ent, PType ptype);
     41
     42  int   MEnt_MasterParID(MEntity_ptr ent);
     43  void  MEnt_Set_MasterParID(MEntity_ptr ent, int masterparid);
     44
     45  int   MEnt_GlobalID(MEntity_ptr ent);
     46  void  MEnt_Set_GlobalID(MEntity_ptr ent, int globalid);
     47  /*end for mpi*/
    2748#endif
    2849
     
    80101                        double *lval, void **pval);
    81102
    82   /* Adhoc routines for parallel output of MSTK files */
     103  /* Adhoc routines for output of parallel FLAG X3D files */
    83104
    84105  int MEnt_NumProcs(MEntity_ptr ent);
  • include/MFace.h

    r354 r471  
    134134  int MF_IsLocked(MFace_ptr f);
    135135
     136#ifdef MSTK_HAVE_MPI
     137 /*for mpi*/
     138  PType MF_PType(MFace_ptr f); 
     139  void  MF_Set_PType(MFace_ptr f, PType ptype);
     140  int   MF_MasterParID(MFace_ptr f);
     141  void  MF_Set_MasterParID(MFace_ptr f, int masterparid);
     142  int   MF_GlobalID(MFace_ptr f);
     143  void  MF_Set_GlobalID(MFace_ptr f, int globalid);
     144  MFace_ptr MF_GhostNew(Mesh_ptr mesh);
     145  /*end for mpi*/
     146#endif
     147
    136148#ifdef __cplusplus
    137149}
  • include/MRegion.h

    r355 r471  
    100100  void MR_Rem_AdjRegion(MRegion_ptr r, MRegion_ptr ar);
    101101
     102#ifdef MSTK_HAVE_MPI
     103  /*for mpi*/
     104  PType MR_PType(MRegion_ptr r); 
     105  void  MR_Set_PType(MRegion_ptr r, PType ptype);
     106  int   MR_MasterParID(MRegion_ptr r);
     107  void  MR_Set_MasterParID(MRegion_ptr r, int masterparid);
     108  int   MR_GlobalID(MRegion_ptr r);
     109  void  MR_Set_GlobalID(MRegion_ptr r, int globalid);
     110  MRegion_ptr MR_GhostNew(Mesh_ptr mesh);
     111  /*end for mpi*/
     112#endif
     113
    102114#ifdef __cplusplus
    103115}
  • include/MSTK.h

    r421 r471  
    22#define _H_MSTK
    33
     4#include <stdarg.h>
    45#ifdef __cplusplus
    56extern "C" {
     
    1314#include "MSTK_malloc.h"
    1415
     16#ifdef MSTK_HAVE_MPI
     17#include <mpi.h>
     18#endif
    1519
    1620/*******************************************************************/
    17 
    18 void        MSTK_Init();
     21void MSTK_Init(void);
    1922
    2023/********************************************************************/
     
    97100  MFace_ptr    MESH_FaceFromID(Mesh_ptr mesh, int i);
    98101  MRegion_ptr  MESH_RegionFromID(Mesh_ptr mesh, int i);
    99 
    100   void       MESH_Set_GModel(Mesh_ptr mesh, GModel_ptr geom);
     102  MEntity_ptr  MESH_EntityFromID(Mesh_ptr mesh, MType mtype, int i);
     103
     104 
     105  int        MESH_SetRepType(Mesh_ptr mesh, RepType type);
     106  void       MESH_SetGModel(Mesh_ptr mesh, GModel_ptr geom);
    101107  int        MESH_Change_RepType(Mesh_ptr mesh, int nurep);
    102108
    103109  void       MESH_Renumber(Mesh_ptr mesh);
    104110
    105   /* Use 'make PAR=1' to include this subroutine. You must link the
    106      METIS libraries. 'part' is an array that contains the partition
    107      number for each mesh face (surface meshes) or mesh region (volume
    108      meshes) */
    109  
    110   int        MESH_PartitionWithMetis(Mesh_ptr mesh, int nparts, int **part);
     111
     112#ifdef MSTK_HAVE_MPI
     113
     114
     115
     116  /* parallel wrapper functions for user */
     117
     118  /* PRIMARY ROUTINES FOR PARALLEL APPLICATION */
     119
     120  /* Read a mesh in, partition it and distribute it to 'num' processors */
     121
     122  int MSTK_Mesh_Read_Distribute(Mesh_ptr *recv_mesh,
     123                                const char* global_mesh_name,
     124                                int dim, int ring, int with_attr,
     125                                int rank, int num, MPI_Comm comm);
     126
     127  /* Partition an existing mesh and distribute it to 'num' processors */
     128
     129  int MSTK_Mesh_Distribute(Mesh_ptr *mesh,
     130                           int dim, int ring, int with_attr,
     131                           int rank, int num, MPI_Comm comm);
     132
     133  /* Parallel update attribute values for ghost entities */
     134
     135  int MSTK_UpdateAttr(Mesh_ptr mesh, int rank, int num,  MPI_Comm comm);
     136
     137  /* END PRIMARY ROUTINES FOR PARALLEL APPLICATION */
     138#endif
     139
     140
    111141
    112142  Hash_ptr MESH_Hash_Edges(Mesh_ptr mesh);
     
    148178  List_ptr MV_Faces(MVertex_ptr mvertex);
    149179  List_ptr MV_Regions(MVertex_ptr mvertex);
     180
     181#ifdef MSTK_HAVE_MPI
     182
     183  /* If you call the routines to set master partition ID or Global ID
     184     without knowing what you are doing, you can shoot yourself in the
     185     foot. So if you are casual MSTK user, you are strongly advised
     186     against calling the Set_MasterParID and Set_GlobalID routines */ 
     187
     188  PType MV_PType(MVertex_ptr v);
     189  void  MV_Set_PType(MVertex_ptr v, PType ptype);
     190  int   MV_MasterParID(MVertex_ptr v);
     191  void  MV_Set_MasterParID(MVertex_ptr v, int masterparid);
     192  int   MV_GlobalID(MVertex_ptr v);
     193  void  MV_Set_GlobalID(MVertex_ptr v, int globalid);
     194#endif
    150195
    151196
     
    191236  void ME_Lock(MEdge_ptr e);
    192237  void ME_UnLock(MEdge_ptr e);
     238
     239#ifdef MSTK_HAVE_MPI
     240 /*for mpi*/
     241  /* If you call the routines to set master partition ID or Global ID
     242     without knowing what you are doing, you can shoot yourself in the
     243     foot. So if you are casual MSTK user, you are strongly advised
     244     against calling the Set_MasterParID and Set_GlobalID routines */ 
     245
     246  PType ME_PType(MEdge_ptr e);
     247  void  ME_Set_PType(MEdge_ptr e, PType ptype);
     248  int   ME_MasterParID(MEdge_ptr e);
     249  void  ME_Set_MasterParID(MEdge_ptr e, int masterparid);
     250  int   ME_GlobalID(MEdge_ptr e);
     251  void  ME_Set_GlobalID(MEdge_ptr e, int globalid);
     252  /*end for mpi*/
     253#endif
    193254
    194255/********************************************************************/
     
    247308  void MF_UnLock(MFace_ptr f);
    248309
     310#ifdef MSTK_HAVE_MPI
     311 /*for mpi*/
     312  /* If you call the routines to set master partition ID or Global ID
     313     without knowing what you are doing, you can shoot yourself in the
     314     foot. So if you are casual MSTK user, you are strongly advised
     315     against calling the Set_MasterParID and Set_GlobalID routines */ 
     316
     317  PType MF_PType(MFace_ptr f); 
     318  void  MF_Set_PType(MFace_ptr f, PType ptype);
     319  int   MF_MasterParID(MFace_ptr f);
     320  void  MF_Set_MasterParID(MFace_ptr f, int masterparid);
     321  int   MF_GlobalID(MFace_ptr f);
     322  void  MF_Set_GlobalID(MFace_ptr f, int globalid);
     323  /*end for mpi*/
     324#endif
     325
    249326/********************************************************************/
    250327/*        MESH REGN OPERATORS                                       */
     
    296373  void MR_Coords(MRegion_ptr mregion, int *n, double (*xyz)[3]);
    297374
     375#ifdef MSTK_HAVE_MPI
     376
     377  /* If you call the routines to set master partition ID or Global ID
     378     without knowing what you are doing, you can shoot yourself in the
     379     foot. So if you are casual MSTK user, you are strongly advised
     380     against calling the Set_MasterParID and Set_GlobalID routines */ 
     381
     382  PType MR_PType(MRegion_ptr r); 
     383  void  MR_Set_PType(MRegion_ptr r, PType ptype);
     384  int   MR_MasterParID(MRegion_ptr r);
     385  void  MR_Set_MasterParID(MRegion_ptr r, int masterparid);
     386  int   MR_GlobalID(MRegion_ptr r);
     387  void  MR_Set_GlobalID(MRegion_ptr r, int globalid);
     388
     389#endif
     390
    298391
    299392  /************************************************************************/
    300393  /* GENERIC ENTITY OPERATORS                                             */
    301394  /************************************************************************/
     395
     396#ifdef MSTK_HAVE_MPI
     397
     398  /* If you call the routines to set master partition ID or Global ID
     399     without knowing what you are doing, you can shoot yourself in the
     400     foot. So if you are casual MSTK user, you are strongly advised
     401     against calling the Set_MasterParID and Set_GlobalID routines */ 
     402
     403  PType MEnt_PType(MEntity_ptr ent);
     404  void  MEnt_Set_PType(MEntity_ptr ent, PType ptype);
     405
     406  int   MEnt_MasterParID(MEntity_ptr ent);
     407  void  MEnt_Set_MasterParID(MEntity_ptr ent, int masterparid);
     408
     409  int   MEnt_GlobalID(MEntity_ptr ent);
     410  void  MEnt_Set_GlobalID(MEntity_ptr ent, int globalid);
     411
     412#endif
    302413
    303414  void MEnt_Set_GEntity(MEntity_ptr mentity, GEntity_ptr gent);
     
    369480  /************************************************************************/
    370481
    371   int  MSTK_GetMarker();
     482  int  MSTK_GetMarker(void);
    372483  void MSTK_FreeMarker(int mkr);
    373484  void MEnt_Mark(MEntity_ptr ent, int mkr);
     
    432543/**********************************************************************/
    433544
     545
     546#ifdef MSTK_HAVE_MPI
     547
     548  /* ROUTINES FOR MORE FINE-GRAINED CONTROL OF PARALLEL APPLICATION  */
     549  /* IF YOU MUCK CALL THESE ROUTINES WITHOUT KNOWING YOUR WAY AROUND */
     550  /* YOU WILL GET WHAT YOU DESERVE                                   */
     551
     552  int MSTK_SendMesh(Mesh_ptr mesh, int rank, int with_attr, MPI_Comm comm);
     553  int MSTK_RecvMesh(Mesh_ptr mesh, int dim, int send_rank, int rank,
     554                    int with_attr, MPI_Comm comm);
     555
     556
     557  /* Mesh Partition Routines*/
     558
     559  int MESH_PartitionWithMetis(Mesh_ptr mesh, int nparts, int **part);
     560  int        MSTK_Mesh_Partition(Mesh_ptr mesh, Mesh_ptr *submeshes, int num,
     561                                 int ring, int with_attr);
     562  int        MESH_Partition(Mesh_ptr mesh, Mesh_ptr *submeshes, int num);
     563  int        MESH_CopyAttr(Mesh_ptr mesh, Mesh_ptr submesh, const char *attr_name);
     564
     565  /* build processor boundary */
     566  int        MESH_BuildPBoundary(Mesh_ptr mesh, Mesh_ptr submesh);
     567
     568  /* add ghost elements */
     569  int        MESH_AddGhost(Mesh_ptr mesh, Mesh_ptr submesh, int part_no, int ring);
     570  /* send and receive mesh */
     571  int        MESH_SendMesh(Mesh_ptr mesh, int rank, MPI_Comm comm);
     572  int        MESH_SendAttr(Mesh_ptr mesh, const char *attr_name, int rank, MPI_Comm comm);
     573  int        MESH_RecvMesh(Mesh_ptr mesh, int dim, int send_rank, int rank, MPI_Comm comm);
     574  int        MESH_RecvAttr(Mesh_ptr mesh, const char *attr_name, int rank, int recv_rank, MPI_Comm comm);
     575
     576  int        MESH_Num_GhostVertices(Mesh_ptr mesh);
     577  int        MESH_Num_GhostEdges(Mesh_ptr mesh);
     578  int        MESH_Num_GhostFaces(Mesh_ptr mesh);
     579  int        MESH_Num_GhostRegions(Mesh_ptr mesh);
     580
     581  int        MESH_Num_OverlapVertices(Mesh_ptr mesh);
     582  int        MESH_Num_OverlapEdges(Mesh_ptr mesh);
     583  int        MESH_Num_OverlapFaces(Mesh_ptr mesh);
     584  int        MESH_Num_OverlapRegions(Mesh_ptr mesh);
     585
     586  int        MESH_Num_InteriorVertices(Mesh_ptr mesh);
     587  int        MESH_Num_InteriorEdges(Mesh_ptr mesh);
     588  int        MESH_Num_InteriorFaces(Mesh_ptr mesh);
     589  int        MESH_Num_InteriorRegions(Mesh_ptr mesh);
     590 
     591  MVertex_ptr  MESH_GhostVertex(Mesh_ptr mesh, int i);
     592  MEdge_ptr    MESH_GhostEdge(Mesh_ptr mesh, int i);
     593  MFace_ptr    MESH_GhostFace(Mesh_ptr mesh, int i);
     594  MRegion_ptr  MESH_GhostRegion(Mesh_ptr mesh, int i);
     595
     596  MVertex_ptr  MESH_OverlapVertex(Mesh_ptr mesh, int i);
     597  MEdge_ptr    MESH_OverlapEdge(Mesh_ptr mesh, int i);
     598  MFace_ptr    MESH_OverlapFace(Mesh_ptr mesh, int i);
     599  MRegion_ptr  MESH_OverlapRegion(Mesh_ptr mesh, int i);
     600
     601  MVertex_ptr  MESH_Next_GhostVertex(Mesh_ptr mesh, int *index);
     602  MEdge_ptr    MESH_Next_GhostEdge(Mesh_ptr mesh, int *index);
     603  MFace_ptr    MESH_Next_GhostFace(Mesh_ptr mesh, int *index);
     604  MRegion_ptr  MESH_Next_GhostRegion(Mesh_ptr mesh, int *index);
     605
     606  MVertex_ptr  MESH_Next_OverlapVertex(Mesh_ptr mesh, int *index);
     607  MEdge_ptr    MESH_Next_OverlapEdge(Mesh_ptr mesh, int *index);
     608  MFace_ptr    MESH_Next_OverlapFace(Mesh_ptr mesh, int *index);
     609  MRegion_ptr  MESH_Next_OverlapRegion(Mesh_ptr mesh, int *index);
     610
     611  MVertex_ptr  MESH_Next_InteriorVertex(Mesh_ptr mesh, int *index);
     612  MEdge_ptr    MESH_Next_InteriorEdge(Mesh_ptr mesh, int *index);
     613  MFace_ptr    MESH_Next_InteriorFace(Mesh_ptr mesh, int *index);
     614  MRegion_ptr  MESH_Next_InteriorRegion(Mesh_ptr mesh, int *index);
     615
     616  /*end for mpi */
     617#endif
    434618
    435619
     
    482666  int      List_Num_Entries(List_ptr l);
    483667  List_ptr List_Cat(List_ptr dest, List_ptr src);
    484 
     668  /* Sort a list based on a user/application supplied comparison function */
     669  void     List_Sort(List_ptr l, size_t num, size_t size,
     670                     int(*comp)(const void *,const void *));
    485671#ifdef DEBUG
    486672  void     List_Print(List_ptr l);
  • include/MSTK_private.h

    r421 r471  
    214214
    215215
     216
     217#ifdef MSTK_HAVE_MPI
     218  /* build ghost list */
     219  int        MESH_Build_GhostLists(Mesh_ptr mesh);
     220
     221  /* create entity */
     222  /* no OvEntity create function since they are just pointers to regular Entity */
     223  MVertex_ptr MV_GhostNew(Mesh_ptr mesh);
     224  MEdge_ptr   ME_GhostNew(Mesh_ptr mesh);
     225  MFace_ptr   MF_GhostNew(Mesh_ptr mesh);
     226  MRegion_ptr MR_GhostNew(Mesh_ptr mesh);
     227
     228
     229  /* functions to update ghost info and attributes */
     230  /* Must be preceded by MESH_UpdateGlobalInfo - Not recommended for users */
     231  int        MESH_UpdateAttr(Mesh_ptr mesh, const char *attr_name, int rank,
     232                             int num,  MPI_Comm comm);
     233  int        MESH_UpdateGlobalInfo(Mesh_ptr mesh, int rank, int num, 
     234                                   MPI_Comm comm);
     235  int*       MESH_GlobalInfo(Mesh_ptr mesh);
     236  int*       MESH_LocalInfo(Mesh_ptr mesh);
     237  void       MESH_Set_GlobalInfo(Mesh_ptr mesh, int *global_info);
     238  void       MESH_Set_LocalInfo(Mesh_ptr mesh, int *local_info);
     239
     240
     241  /* Functions for entity sets */
     242
     243  int        MESH_CopySet(Mesh_ptr mesh, Mesh_ptr submesh, MSet_ptr mset);
     244  int        MESH_SendMSet(Mesh_ptr mesh, const char *set_name, int rank, MPI_Comm comm);
     245  int        MESH_RecvMSet(Mesh_ptr mesh, const char *set_name, int rank, int recv_rank, MPI_Comm comm);
     246
     247
     248  /**** ????????? ******/
     249  /* the following 16 functions is not necessary,
     250     we can operate on the whole list, and then call
     251     MESH_BuildGhostList()
     252  */
     253  void       MESH_Add_GhostVertex(Mesh_ptr mesh, MVertex_ptr v);
     254  void       MESH_Add_GhostEdge(Mesh_ptr mesh, MEdge_ptr e);
     255  void       MESH_Add_GhostFace(Mesh_ptr mesh, MFace_ptr f);
     256  void       MESH_Add_GhostRegion(Mesh_ptr mesh, MRegion_ptr r);
     257
     258  void       MESH_Add_OverlapVertex(Mesh_ptr mesh, MVertex_ptr v);
     259  void       MESH_Add_OverlapEdge(Mesh_ptr mesh, MEdge_ptr e);
     260  void       MESH_Add_OverlapFace(Mesh_ptr mesh, MFace_ptr f);
     261  void       MESH_Add_OverlapRegion(Mesh_ptr mesh, MRegion_ptr r);
     262
     263  void       MESH_Rem_GhostVertex(Mesh_ptr mesh, MVertex_ptr v);
     264  void       MESH_Rem_GhostEdge(Mesh_ptr mesh, MEdge_ptr e);
     265  void       MESH_Rem_GhostFace(Mesh_ptr mesh, MFace_ptr f);
     266  void       MESH_Rem_GhostRegion(Mesh_ptr mesh, MRegion_ptr r);
     267
     268 
     269  void       MESH_Rem_OverlapVertex(Mesh_ptr mesh, MVertex_ptr v);
     270  void       MESH_Rem_OverlapEdge(Mesh_ptr mesh, MEdge_ptr e);
     271  void       MESH_Rem_OverlapFace(Mesh_ptr mesh, MFace_ptr f);
     272  void       MESH_Rem_OverlapRegion(Mesh_ptr mesh, MRegion_ptr r);
     273
     274  int compareGlobalID(MEntity_ptr *a, MEntity_ptr *b);
     275#endif
     276
     277
    216278#ifdef __cplusplus
    217279           }
  • include/MSTK_types.h

    r405 r471  
    5151
    5252typedef enum MType {MDELETED=-1, MVERTEX=0, MEDGE=1, MFACE=2, MREGION=3, MUNKNOWNTYPE=4, MALLTYPE=5} MType;
    53 
     53 
     54#ifdef MSTK_HAVE_MPI
     55/* PINTERIOR is the interior in a submesh, no need to get broadcast
     56   POVERLAP also belongs to this submesh, but may be used as ghost entities of another processor
     57   PBOUNDARY indicates processor boundary
     58   PGHOST indicates ghost elements;
     59*/
     60typedef enum PType {PINTERIOR=0, POVERLAP=1, PBOUNDARY=2, PGHOST=3} PType;
     61#endif
    5462
    5563/* typedefs needed for attributes */
  • include/MVertex.h

    r356 r471  
    105105  void MV_Rem_Region(MVertex_ptr mvertex, MRegion_ptr mregion);
    106106
     107#ifdef MSTK_HAVE_MPI
     108  /*for mpi*/
     109  PType MV_PType(MVertex_ptr r); 
     110  void  MV_Set_PType(MVertex_ptr r, PType ptype);
     111  int   MV_MasterParID(MVertex_ptr r);
     112  void  MV_Set_MasterParID(MVertex_ptr r, int masterparid);
     113  int   MV_GlobalID(MVertex_ptr r);
     114  void  MV_Set_GlobalID(MVertex_ptr r, int globalid);
     115  MVertex_ptr MV_GhostNew(Mesh_ptr mesh);
     116  /*end for mpi*/
     117#endif
     118
    107119#ifdef __cplusplus
    108120}
  • include/Mesh.h

    r405 r471  
    55#include "MSTK_types.h"
    66
    7 #ifdef _cplusplus
     7#ifdef __cplusplus
    88extern "C" {
    99#endif
     
    2020    Hash_ptr hedge, hface;
    2121    int autolock;
     22
     23#ifdef MSTK_HAVE_MPI
     24    /* for mpi */
     25    List_ptr ghvertex, ghedge, ghface, ghregion;
     26    int max_ghvid, max_gheid, max_ghfid, max_ghrid;
     27    List_ptr ovvertex, ovedge, ovface, ovregion;
     28    int *global_info;
     29    int *local_info;
     30    /* end for mpi */
     31#endif
    2232  } Mesh, *Mesh_ptr;
    2333#else
     
    7686  void       MESH_Rem_Region(Mesh_ptr mesh, MRegion_ptr r);
    7787
     88#ifdef HAVE_MPI
     89  int        MESH_Num_GhostVertices(Mesh_ptr mesh);
     90  int        MESH_Num_GhostEdges(Mesh_ptr mesh);
     91  int        MESH_Num_GhostFaces(Mesh_ptr mesh);
     92  int        MESH_Num_GhostRegions(Mesh_ptr mesh);
     93
     94  MVertex_ptr  MESH_GhostVertex(Mesh_ptr mesh, int i);
     95  MEdge_ptr    MESH_GhostEdge(Mesh_ptr mesh, int i);
     96  MFace_ptr    MESH_GhostFace(Mesh_ptr mesh, int i);
     97  MRegion_ptr  MESH_GhostRegion(Mesh_ptr mesh, int i);
     98 
     99  MVertex_ptr  MESH_Next_GhostVertex(Mesh_ptr mesh, int *index);
     100  MEdge_ptr    MESH_Next_GhostEdge(Mesh_ptr mesh, int *index);
     101  MFace_ptr    MESH_Next_GhostFace(Mesh_ptr mesh, int *index);
     102  MRegion_ptr  MESH_Next_GhostRegion(Mesh_ptr mesh, int *index);
     103
     104  void       MESH_Add_GhostVertex(Mesh_ptr mesh, MVertex_ptr v);
     105  void       MESH_Add_GhostEdge(Mesh_ptr mesh, MEdge_ptr e);
     106  void       MESH_Add_GhostFace(Mesh_ptr mesh, MFace_ptr f);
     107  void       MESH_Add_GhostRegion(Mesh_ptr mesh, MRegion_ptr r);
     108
     109  void       MESH_Rem_GhostVertex(Mesh_ptr mesh, MVertex_ptr v);
     110  void       MESH_Rem_GhostEdge(Mesh_ptr mesh, MEdge_ptr e);
     111  void       MESH_Rem_GhostFace(Mesh_ptr mesh, MFace_ptr f);
     112  void       MESH_Rem_GhostRegion(Mesh_ptr mesh, MRegion_ptr r);
     113
     114  int        MESH_Num_OverlapVertices(Mesh_ptr mesh);
     115  int        MESH_Num_OverlapEdges(Mesh_ptr mesh);
     116  int        MESH_Num_OverlapFaces(Mesh_ptr mesh);
     117  int        MESH_Num_OverlapRegions(Mesh_ptr mesh);
     118
     119  MVertex_ptr  MESH_OverlapVertex(Mesh_ptr mesh, int i);
     120  MEdge_ptr    MESH_OverlapEdge(Mesh_ptr mesh, int i);
     121  MFace_ptr    MESH_OverlapFace(Mesh_ptr mesh, int i);
     122  MRegion_ptr  MESH_OverlapRegion(Mesh_ptr mesh, int i);
     123
     124  MVertex_ptr  MESH_Next_OverlapVertex(Mesh_ptr mesh, int *index);
     125  MEdge_ptr    MESH_Next_OverlapEdge(Mesh_ptr mesh, int *index);
     126  MFace_ptr    MESH_Next_OverlapFace(Mesh_ptr mesh, int *index);
     127  MRegion_ptr  MESH_Next_OverlapRegion(Mesh_ptr mesh, int *index);
     128
     129  void       MESH_Add_OverlapVertex(Mesh_ptr mesh, MVertex_ptr v);
     130  void       MESH_Add_OverlapEdge(Mesh_ptr mesh, MEdge_ptr e);
     131  void       MESH_Add_OverlapFace(Mesh_ptr mesh, MFace_ptr f);
     132  void       MESH_Add_OverlapRegion(Mesh_ptr mesh, MRegion_ptr r);
     133
     134#endif
     135
    78136  void       MESH_Set_GModel(Mesh_ptr mesh, GModel_ptr geom);
    79137  int        MESH_Change_RepType(Mesh_ptr mesh, int nurep);
     
    86144  void MESH_Set_AutoLock(Mesh_ptr mesh, int autolock);
    87145 
    88 #ifdef _cplusplus
     146#ifdef __cplusplus
    89147}
    90148#endif
Note: See TracChangeset for help on using the changeset viewer.