Changeset 471:871f56e7ce10


Ignore:
Timestamp:
02/17/11 15:00:19 (3 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.