|
MOAB: Mesh Oriented datABase
(version 5.4.1)
|
|
MOAB: Mesh Oriented datABase
(version 5.4.1)
|
00001 #ifndef _ITAPS_iMeshP 00002 #define _ITAPS_iMeshP 00003 00004 #include "iMesh.h" 00005 #include "iMeshP_protos.h" 00006 #include "moab_mpi.h" 00007 00008 #ifdef __cplusplus 00009 extern "C" { 00010 #endif 00011 00012 /** Handles needed in iMeshP */ 00013 typedef struct iMeshP_PartitionHandle_Private* iMeshP_PartitionHandle; 00014 typedef struct iMeshP_RequestHandle_Private* iMeshP_RequestHandle; 00015 00016 /* Since we allow overloading of iMesh functions' entity set handles with 00017 * part handles, iMeshP_PartHandle must be defined the same as 00018 * iBase_EntitySetHandle. */ 00019 typedef iBase_EntitySetHandle iMeshP_PartHandle; 00020 00021 typedef unsigned iMeshP_Part; 00022 00023 /** Types for classifying entities within a part. */ 00024 enum iMeshP_EntStatus 00025 { 00026 iMeshP_INTERNAL, /**< An owned entity that is not on a part boundary. */ 00027 iMeshP_BOUNDARY, /**< A shared entity on a part boundary. */ 00028 iMeshP_GHOST /**< An entity copy that is not a shared boundary entity. */ 00029 }; 00030 00031 /** Part ID number indicating information should be returned about all parts. */ 00032 #define iMeshP_ALL_PARTS ( -1 ) 00033 00034 /** \page imeshp iMeshP: ITAPS Parallel Mesh Interface 00035 iMeshP.h -- ITAPS Parallel Mesh Interface 00036 00037 Release 0.1; October 2008 00038 00039 \section ADM Abstract Data Model 00040 - The term "mesh" refers to an abstraction in the data model; 00041 it does not imply a serial or parallel distribution. 00042 - The term "partition" refers to an assignment of a set of entities to 00043 subsets; like a "mesh," it does not imply a serial or parallel 00044 implementation. 00045 - An application may use one or more meshes. 00046 - Partitions can create subsets of entities from one or more meshes. 00047 - Meshes can be subdivided by one or more partitions. 00048 - Partitions contain parts. Parts contain the subsets of entities in the 00049 partition. 00050 00051 \section PAR Parallelism 00052 - A "process" can be thought of as an MPI process. The 00053 number of processes can be considered to be the result of MPI_Comm_size. 00054 The rank of a process can be thought of as the result of MPI_Comm_rank. 00055 We will think in terms of processes rather than processors. Initial 00056 implementations of the parallel interface will likely use MPI terminology 00057 directly; future implementations may accommodate other communication 00058 paradigms and libraries. 00059 - Partitions have communicators associated with them. These communicators 00060 can be thought of as MPI communicators. 00061 - "Global" operations are operations performed with respect to a 00062 partition's communicator. 00063 - "Local" operations are operations performed with respect to a part or 00064 a mesh instance within a process. 00065 - Part A "neighbors" Part B if Part A has copies of entities owned by Part B 00066 and/or if Part B has copies of entities owned by Part A. 00067 00068 \section INT Interfaces 00069 - Each process has one or more "mesh instances." A mesh instance can be 00070 thought of as a mesh database. An implementation should support the 00071 existence of more than one mesh instance per process (e.g., it should 00072 always associate mesh data with a mesh instance). However, we expect 00073 applications would most often use only one mesh instance per process. 00074 - There is one root set per mesh instance. 00075 - Each process may have one or more partition handles. 00076 - A partition assigns entities from one mesh instance to parts. 00077 - Entities in a mesh instance can be partitioned by one or more partitions. 00078 Mesh instances know which partitions they contain. 00079 - Parts are uniquely identified globally by part IDs of type iMeshP_Part. 00080 Local parts can also be accessed by part handles that provide more 00081 direct access to a part. 00082 Functions accepting part handles operate correctly on only local 00083 parts (parts on the calling process); they will return an error 00084 for remote (off-process) parts. 00085 - Generation and management of global IDs for entities 00086 is not included in the iMeshP interface. It can 00087 be provided as a service above the iMeshP interface. 00088 Uniqueness of global IDs is managed at the partition level. 00089 00090 \section PRT Using Parts 00091 - Each part is wholly contained within a process. 00092 - A process may have zero, one or multiple parts. 00093 - For each entity that is copied onto remote parts, the owning part knows 00094 both the remote part ID and remote entity handle of all copies. 00095 - All parts with copies of a boundary entity know the remote part ID 00096 and remote entity handle of all copies of the entity. 00097 - All parts with copies of any entity know the part ID and 00098 entity handle corresponding to the owner of the entity. 00099 - Functions that return entity information for a part, set or mesh 00100 instance return the information for all entities (including copies and 00101 ghosts) in that part, set or mesh instance. Applications can check 00102 whether an entity is owned or a ghost using iMeshP_isEntOwner or 00103 iMeshP_getEntStatus. 00104 - Many iMesh functions that accept an iBase_EntitySetHandle 00105 are also useful in the context of a iMeshP_PartHandle. 00106 These functions are reinterpreted so that they can accept either an 00107 iBase_EntitySetHandle or an iMeshP_PartHandle. 00108 - In particular, entities are added to and removed from local parts via 00109 the same functions that are used to manipulate entity sets. 00110 That is, given a mesh instance, an entity handle, and a part handle, 00111 the entity is added to or removed from the part via calls to 00112 the following functions with the part handle passed as the entity set handle: 00113 - Add entity to part --> iMesh_addEntToSet 00114 - Remove entity from part --> iMesh_rmvEntFromSet 00115 - Add array of entities to part --> iMesh_addEntArrToSet 00116 - Remove array of entities from part --> iMesh_rmvEntArrFromSet 00117 00118 \section CMM Communication 00119 - Each function description includes its communication requirements. The 00120 options are described here: 00121 - COMMUNICATION: Collective -- the function must be called by all 00122 processes in the partition's communicator. (These functions have the 00123 suffix "All" to indicate collective communication is done.) 00124 - COMMUNICATION: Point-to-Point -- communication is used, but the 00125 communication is from one process to only one other process. The 00126 receiving process must issue an appropriate receive call to receive 00127 the message. 00128 - COMMUNICATION: None -- the function does not use communication; only 00129 local operations are performed. 00130 - COMMUNICATION: None++ -- no communication is done; the values 00131 are precomputed by iMeshP_syncPartitionAll or iMeshP_syncMeshAll. 00132 - Non-blocking calls for off-processor mesh-modification return a request 00133 that indicates whether or not the operation has completed. The request 00134 is more than an MPI request; it encapsulates both the MPI information and 00135 the mesh operations that were requested. If non-blocking calls are used, 00136 appropriate calls to iMeshP "wait" or "poll" functions must be used to 00137 handle and satisfy requests. 00138 */ 00139 00140 /*------------------------------------------------------------------------*/ 00141 /*------------------------------------------------------------------------*/ 00142 /* Partition Functionality */ 00143 /*------------------------------------------------------------------------*/ 00144 /*------------------------------------------------------------------------*/ 00145 00146 /** \brief Create a partition; return its handle. 00147 * 00148 * Given a mesh instance and a communicator, 00149 * return a partition handle for a new partition within the mesh instance 00150 * that uses the communicator. 00151 * In the future, we may have different creation routines for different 00152 * communication systems; once the partition is created, the application 00153 * would not have to worry about the communication system again. 00154 * For now, implementations are MPI based, so MPI communicators are provided. 00155 * For serial use, the communicator may be MPI_COMM_SELF or communicator may 00156 * be NULL. 00157 * 00158 * COMMUNICATION: Collective. 00159 * 00160 * \param instance (In) Mesh instance to contain the partition. 00161 * \param communicator (In) Communicator to be used for parallel 00162 * communication. 00163 * \param partition (Out) The newly created partition. 00164 * \param err (Out) Error code. 00165 */ 00166 void iMeshP_createPartitionAll( iMesh_Instance instance, 00167 MPI_Comm communicator, 00168 iMeshP_PartitionHandle* partition, 00169 int* err ); 00170 00171 /** \brief Destroy a partition. 00172 * 00173 * Given a partition handle, 00174 * destroy the partition associated with the handle. 00175 * Note that the partition handle is not invalidated upon return. 00176 * 00177 * COMMUNICATION: Collective. 00178 * 00179 * \param instance (In) Mesh instance containing the partition. 00180 * \param partition (In) The partition to be destroyed. 00181 * \param err (Out) Error code. 00182 */ 00183 void iMeshP_destroyPartitionAll( iMesh_Instance instance, iMeshP_PartitionHandle partition, int* err ); 00184 00185 /** \brief Return communicator associated with a partition. 00186 * 00187 * Given a partition handle, return the communicator associated with 00188 * it during its creation by iMeshP_createPartitionAll. 00189 * 00190 * COMMUNICATION: None 00191 * 00192 * \param instance (In) Mesh instance containing the partition. 00193 * \param partition (In) The partition being queried. 00194 * \param communicator (Out) Communicator associated with the partition. 00195 * \param err (Out) Error code. 00196 */ 00197 void iMeshP_getPartitionComm( iMesh_Instance instance, 00198 iMeshP_PartitionHandle partition, 00199 MPI_Comm* communicator, 00200 int* err ); 00201 00202 /** \brief Update a partition after parts have been added. 00203 * 00204 * This function gives the implementation an opportunity to locally store info 00205 * about the partition so that queries on the partition can be 00206 * performed without synchronous communication. 00207 * This function must be called after all parts have been added to the 00208 * partition and after changes to the partition (e.g., due to load balancing). 00209 * Values that are precomputed by syncPartitionAll include: 00210 * - the total number of parts in a partition; 00211 * - the mapping between part IDs and processes; and 00212 * - updated remote entity handle information. 00213 * 00214 * COMMUNICATION: Collective. 00215 * 00216 * \param instance (In) Mesh instance containing the partition. 00217 * \param partition (In) The partition being updated. 00218 * \param err (Out) Error code. 00219 */ 00220 void iMeshP_syncPartitionAll( iMesh_Instance instance, iMeshP_PartitionHandle partition, int* err ); 00221 00222 /** \brief Return the number of partitions associated with a mesh instance. 00223 * 00224 * Given a mesh instance, return the number of partition handles 00225 * associated with the mesh instance. 00226 * 00227 * COMMUNICATION: None. 00228 * 00229 * \param instance (In) Mesh instance containing the partitions. 00230 * \param num_partitions (Out) Number of partitions associated with the 00231 * mesh instance. 00232 * \param err (Out) Error code. 00233 */ 00234 void iMeshP_getNumPartitions( iMesh_Instance instance, int* num_partitions, int* err ); 00235 00236 /** \brief Return the partition handles associated with a mesh instance. 00237 * 00238 * Given a mesh instance, return all partition handles 00239 * associated with the mesh instance. 00240 * 00241 * COMMUNICATION: None. 00242 * 00243 * \param instance (In) Mesh instance containing the 00244 * partitions. 00245 * \param partitions (In/Out) Array of partition handles 00246 * associated with the mesh 00247 * instance. 00248 * \param partitions_allocated (In/Out) Allocated size of 00249 * partitions array. 00250 * \param partitions_size (Out) Occupied size of 00251 * partitions array. 00252 * \param err (Out) Error code. 00253 */ 00254 void iMeshP_getPartitions( iMesh_Instance instance, 00255 iMeshP_PartitionHandle** partitions, 00256 int* partitions_allocated, 00257 int* partitions_size, 00258 int* err ); 00259 00260 /** \brief Return the global number of parts in a partition. 00261 * 00262 * Given a partition handle, return the total number of parts 00263 * in the partition across all processes in the partition's communicator. 00264 * 00265 * COMMUNICATION: None++. 00266 * 00267 * \param instance (In) Mesh instance containing the partition. 00268 * \param partition (In) The partition being queried. 00269 * \param num_global_part (Out) Global number of parts in the partition. 00270 * \param err (Out) Error code. 00271 */ 00272 void iMeshP_getNumGlobalParts( iMesh_Instance instance, 00273 const iMeshP_PartitionHandle partition, 00274 int* num_global_part, 00275 int* err ); 00276 00277 /** \brief Return the local number of parts in a partition. 00278 * 00279 * Given a partition handle, return the number of local (on-process) parts 00280 * in the partition. 00281 * 00282 * COMMUNICATION: None. 00283 * 00284 * \param instance (In) Mesh instance containing the partition. 00285 * \param partition (In) The partition being queried. 00286 * \param num_local_part (Out) Local (on-process) number of parts in 00287 * the partition. 00288 * \param err (Out) Error code. 00289 */ 00290 void iMeshP_getNumLocalParts( iMesh_Instance instance, 00291 const iMeshP_PartitionHandle partition, 00292 int* num_local_part, 00293 int* err ); 00294 00295 /** \brief Return the part handles of local parts in a partition. 00296 * 00297 * Given a partition handle, return the 00298 * part handles for the local (on-process) parts in the partition. 00299 * 00300 * COMMUNICATION: None. 00301 * 00302 * \param instance (In) Mesh instance containing the 00303 * partition. 00304 * \param partition (In) The partition being queried. 00305 * \param parts (In/Out) Array of part handles 00306 * for local parts in the partition. 00307 * \param parts_allocated (In/Out) Allocated size of 00308 * parts array. 00309 * \param parts_size (Out) Occupied size of 00310 * parts array. 00311 * \param err (Out) Error code. 00312 */ 00313 void iMeshP_getLocalParts( iMesh_Instance instance, 00314 const iMeshP_PartitionHandle partition, 00315 iMeshP_PartHandle** parts, 00316 int* parts_allocated, 00317 int* parts_size, 00318 int* err ); 00319 00320 /** \brief Return the process rank of a given part. 00321 * 00322 * Given a partition handle and a part ID, return the process rank 00323 * (with respect to the partition's communicator) of the 00324 * process that owns the part. The part may be local or remote. 00325 * 00326 * COMMUNICATION: None++. 00327 * 00328 * \param instance (In) Mesh instance containing the partition. 00329 * \param partition (In) The partition being queried. 00330 * \param part_id (In) Part ID for the part being queried. 00331 * \param rank (Out) Process rank of part_id. 00332 * \param err (Out) Error code. 00333 */ 00334 void iMeshP_getRankOfPart( iMesh_Instance instance, 00335 const iMeshP_PartitionHandle partition, 00336 const iMeshP_Part part_id, 00337 int* rank, 00338 int* err ); 00339 00340 /** \brief Return the process ranks of given parts. 00341 * 00342 * Given a partition handle and an array of part IDs, return the process ranks 00343 * (with respect to the partition's communicator) of the 00344 * process that owns each part. The parts may be local or remote. 00345 * 00346 * COMMUNICATION: None++. 00347 * 00348 * \param instance (In) Mesh instance containing the partition. 00349 * \param partition (In) The partition being queried. 00350 * \param part_ids (In) Array of Part IDs for the parts being 00351 * queried. 00352 * \param part_ids_size (In) The number of Part IDs in part_ids. 00353 * \param ranks (In/Out) Array of ranks for the Part Ids in 00354 * part_ids. 00355 * \param ranks_allocated (In/Out) Allocated size of ranks array. 00356 * \param ranks_size (Out) Occupied size of ranks array. 00357 * \param err (Out) Error code. 00358 */ 00359 void iMeshP_getRankOfPartArr( iMesh_Instance instance, 00360 const iMeshP_PartitionHandle partition, 00361 const iMeshP_Part* part_ids, 00362 const int part_ids_size, 00363 int** ranks, 00364 int* ranks_allocated, 00365 int* ranks_size, 00366 int* err ); 00367 00368 /** \brief Return the number of entities of a given type in a partition. 00369 * 00370 * Given a partition handle and an entity set (possibly the root set), 00371 * return the global number of entities of a 00372 * given entity type in the partition and set. This function may require 00373 * communication and, thus, must be called by all processes in the partition's 00374 * communicator. 00375 * 00376 * COMMUNICATION: Collective. 00377 * 00378 * \param instance (In) Mesh instance containing the partition. 00379 * \param partition (In) The partition being queried. 00380 * \param entity_set (In) Entity set handle for the entity set 00381 * being queried. 00382 * \param entity_type (In) Requested entity type; 00383 * may be iBase_ALL_TYPES. 00384 * \param num_type (Out) Number of entities of entity_type in 00385 * the partition and entity set. 00386 * \param err (Out) Error code. 00387 */ 00388 void iMeshP_getNumOfTypeAll( iMesh_Instance instance, 00389 const iMeshP_PartitionHandle partition, 00390 const iBase_EntitySetHandle entity_set, 00391 int entity_type, 00392 int* num_type, 00393 int* err ); 00394 00395 /** \brief Return the number of entities of a given topology in a partition. 00396 * 00397 * Given a partition handle and an entity set (possibly the root set), 00398 * return the global number of entities of a 00399 * given entity topology in the partition and set. This function may require 00400 * communication and, thus, must be called by all processes in the partition's 00401 * communicator. 00402 * 00403 * COMMUNICATION: Collective. 00404 * 00405 * \param instance (In) Mesh instance containing the partition. 00406 * \param partition (In) The partition being queried. 00407 * \param entity_set (In) Entity set handle for the entity set 00408 * being queried; may be the root set. 00409 * \param entity_topology (In) Requested entity topology; 00410 * may be iMesh_ALL_TOPOLOGIES. 00411 * \param num_topo (Out) Number of entities with entity_topology in 00412 * the partition and entity set. 00413 * \param err (Out) Error code. 00414 */ 00415 void iMeshP_getNumOfTopoAll( iMesh_Instance instance, 00416 const iMeshP_PartitionHandle partition, 00417 const iBase_EntitySetHandle entity_set, 00418 int entity_topology, 00419 int* num_topo, 00420 int* err ); 00421 00422 /*------------------------------------------------------------------------*/ 00423 /*------------------------------------------------------------------------*/ 00424 /* Part Functionality */ 00425 /*------------------------------------------------------------------------*/ 00426 /*------------------------------------------------------------------------*/ 00427 00428 /** \brief Create a new part in a partition. 00429 * 00430 * Given a partition handle, create a new part and add it to the 00431 * partition on the process invoking the creation. Return the part handle 00432 * for the new part. 00433 * 00434 * COMMUNICATION: None. 00435 * 00436 * \param instance (In) Mesh instance containing the partition. 00437 * \param partition (In) The partition being updated. 00438 * \param part (Out) The newly created part. 00439 * \param err (Out) Error code. 00440 */ 00441 void iMeshP_createPart( iMesh_Instance instance, iMeshP_PartitionHandle partition, iMeshP_PartHandle* part, int* err ); 00442 00443 /** \brief Remove a part from a partition. 00444 * 00445 * Given a partition handle and a part handle, remove the part 00446 * from the partition and destroy the part. Note that the part handle 00447 * is not invalidated by this function. 00448 * 00449 * COMMUNICATION: None. 00450 * 00451 * \param instance (In) Mesh instance containing the partition. 00452 * \param partition (In) The partition being updated. 00453 * \param part (In) The part to be removed. 00454 * \param err (Out) Error code. 00455 */ 00456 void iMeshP_destroyPart( iMesh_Instance instance, iMeshP_PartitionHandle partition, iMeshP_PartHandle part, int* err ); 00457 00458 /** \brief Obtain a part ID from a part handle. 00459 * 00460 * Given a partition handle and a local part handle, return the part ID. 00461 * If the part handle is not a valid part handle for a local part, 00462 * an error is returned. 00463 * 00464 * COMMUNICATION: None. 00465 * 00466 * \param instance (In) Mesh instance containing the partition. 00467 * \param partition (In) The partition being queried. 00468 * \param part (In) The part being queried. 00469 * \param part_id (Out) Part ID for part. 00470 * \param err (Out) Error code. 00471 */ 00472 void iMeshP_getPartIdFromPartHandle( iMesh_Instance instance, 00473 const iMeshP_PartitionHandle partition, 00474 const iMeshP_PartHandle part, 00475 iMeshP_Part* part_id, 00476 int* err ); 00477 00478 /** \brief Obtain part IDs from part handles. 00479 * 00480 * Given a partition handle and an array of local part handles, 00481 * return the part ID for each part handle. 00482 * If any part handle is not a valid part handle for a local part, 00483 * an error is returned. 00484 * 00485 * COMMUNICATION: None. 00486 * 00487 * \param instance (In) Mesh instance containing the partition. 00488 * \param partition (In) The partition being queried. 00489 * \param parts (In) Array of part handles for the parts 00490 * being queried. 00491 * \param parts_size (In) Number of part handles being queried. 00492 * \param part_ids (In/Out) Array of part IDs associated with the 00493 * parts. 00494 * \param part_ids_allocated (In/Out) Allocated size of part_ids array. 00495 * \param part_ids_size (Out) Occupied size of part_ids array. 00496 * \param err (Out) Error code. 00497 */ 00498 void iMeshP_getPartIdsFromPartHandlesArr( iMesh_Instance instance, 00499 const iMeshP_PartitionHandle partition, 00500 const iMeshP_PartHandle* parts, 00501 const int parts_size, 00502 iMeshP_Part** part_ids, 00503 int* part_ids_allocated, 00504 int* part_ids_size, 00505 int* err ); 00506 00507 /** \brief Obtain a part handle from a part ID. 00508 * 00509 * Given a partition handle and a part ID, return the part handle 00510 * associated with the part 00511 * if the part is local; otherwise, return an error code. 00512 * 00513 * COMMUNICATION: None. 00514 * 00515 * \param instance (In) Mesh instance containing the partition. 00516 * \param partition (In) The partition being queried. 00517 * \param part_id (In) Part ID for the part being queried. 00518 * \param part (Out) Part handle associated with part_id. 00519 * \param err (Out) Error code. 00520 */ 00521 void iMeshP_getPartHandleFromPartId( iMesh_Instance instance, 00522 const iMeshP_PartitionHandle partition, 00523 iMeshP_Part part_id, 00524 iMeshP_PartHandle* part, 00525 int* err ); 00526 00527 /** \brief Obtain part handles from part IDs. 00528 * 00529 * Given a partition handle and an array of local part IDs, 00530 * return the part handle for each part ID. 00531 * If any part ID is not a valid part ID for a local part, 00532 * an error is returned. 00533 * 00534 * COMMUNICATION: None. 00535 * 00536 * \param instance (In) Mesh instance containing the 00537 * partition. 00538 * \param partition (In) The partition being queried. 00539 * \param part_ids (In) Array of part IDs for the parts 00540 * being queried. 00541 * \param part_ids_size (In) Number of part IDs being queried. 00542 * \param parts (In/Out) Array of part handles associated 00543 * with the part_ids. 00544 * \param parts_allocated (In/Out) Allocated size of parts 00545 * array. 00546 * \param parts_size (Out) Occupied size of parts 00547 * array. 00548 * \param err (Out) Error code. 00549 */ 00550 void iMeshP_getPartHandlesFromPartsIdsArr( iMesh_Instance instance, 00551 const iMeshP_PartitionHandle partition, 00552 const iMeshP_Part* part_ids, 00553 const int part_ids_size, 00554 iMeshP_PartHandle** parts, 00555 int* parts_allocated, 00556 int* parts_size, 00557 int* err ); 00558 00559 /*------------------------------------------------------------------------*/ 00560 /* Part Boundaries */ 00561 /*------------------------------------------------------------------------*/ 00562 00563 /** \brief Return the number of parts that neighbor a given part. 00564 * 00565 * Given a partition handle, a part handle, and an entity type, 00566 * return the number of parts in the partition that neighbor the given part 00567 * (i.e., that (1) have copies of entities of the given entity type owned by 00568 * the given part or (2) own entities of the given entity type that are 00569 * copied on the given part). 00570 * 00571 * COMMUNICATION: None++. 00572 * 00573 * \param instance (In) Mesh instance containing the partition. 00574 * \param partition (In) The partition being queried. 00575 * \param part (In) The part being queried. 00576 * \param entity_type (In) Entity type of the copied entities; 00577 * may be iBase_ALL_TYPES. 00578 * \param num_part_nbors (Out) Number of parts neighboring the given part. 00579 * \param err (Out) Error code. 00580 */ 00581 void iMeshP_getNumPartNbors( iMesh_Instance instance, 00582 const iMeshP_PartitionHandle partition, 00583 const iMeshP_PartHandle part, 00584 int entity_type, 00585 int* num_part_nbors, 00586 int* err ); 00587 00588 /** \brief Return the number of parts that neighbor given parts. 00589 * 00590 * Given a partition handle, an array of part handles, and an entity type, 00591 * return the number of parts in the partition that neighbor each of the 00592 * given parts 00593 * (i.e., that (1) have copies of entities of the given entity type owned by 00594 * the given part or (2) own entities of the given entity type that are 00595 * copied on the given part). 00596 * 00597 * COMMUNICATION: None++. 00598 * 00599 * \param instance (In) Mesh instance containing the 00600 * partition. 00601 * \param partition (In) The partition being queried. 00602 * \param parts (In) Array of part handles for the 00603 * parts being queried. 00604 * \param parts_size (In) Number of part handles in 00605 * parts. 00606 * \param entity_type (In) Entity type of the copied 00607 * entities; 00608 * may be iBase_ALL_TYPES. 00609 * \param num_part_nbors (In/Out) Array of values specifying the 00610 * number of part neighbors for 00611 * each part in parts. 00612 * \param num_part_nbors_allocated (In/Out) Allocated size of num_part_nbors 00613 * array. 00614 * \param num_part_nbors_size (Out) Occupied size of num_part_nbors 00615 * array. 00616 * \param err (Out) Error code. 00617 */ 00618 void iMeshP_getNumPartNborsArr( iMesh_Instance instance, 00619 const iMeshP_PartitionHandle partition, 00620 const iMeshP_PartHandle* parts, 00621 int parts_size, 00622 int entity_type, 00623 int** num_part_nbors, 00624 int* num_part_nbors_allocated, 00625 int* num_part_nbors_size, 00626 int* err ); 00627 00628 /** \brief Return the parts that neighbor a given part. 00629 * 00630 * Given a partition handle, a part handle, and an entity type, 00631 * return the part IDs of parts that neighbor the given part 00632 * (i.e., that (1) have copies of entities of the given entity type owned by 00633 * the given part or (2) own entities of the given entity type that are 00634 * copied on the given part). 00635 * 00636 * COMMUNICATION: None++. 00637 * 00638 * \param instance (In) Mesh instance containing the 00639 * partition. 00640 * \param partition (In) The partition being queried. 00641 * \param part (In) The part being queried. 00642 * \param entity_type (In) Entity type of the copied 00643 * entities; 00644 * may be iBase_ALL_TYPES. 00645 * \param num_part_nbors (Out) Number of parts neighboring 00646 * the given part. 00647 * \param nbor_part_ids (In/Out) Array of part IDs for 00648 * part neighbors of part. 00649 * \param nbor_part_ids_allocated (In/Out) Allocated size of nbor_part_ids 00650 * array. 00651 * \param nbor_part_ids_size (Out) Occupied size of nbor_part_ids 00652 * array. 00653 * \param err (Out) Error code. 00654 */ 00655 void iMeshP_getPartNbors( iMesh_Instance instance, 00656 const iMeshP_PartitionHandle partition, 00657 const iMeshP_PartHandle part, 00658 int entity_type, 00659 int* num_part_nbors, 00660 iMeshP_Part** nbor_part_ids, 00661 int* nbor_part_ids_allocated, 00662 int* nbor_part_ids_size, 00663 int* err ); 00664 00665 /** \brief Return the parts that neighbor given parts. 00666 * 00667 * Given a partition handle, an array of part handles, and an entity type, 00668 * return the part IDs of parts that neighbor the given parts 00669 * (i.e., that (1) have copies of entities of the given entity type owned by 00670 * the given part or (2) own entities of the given entity type that are 00671 * copied on the given part). 00672 * 00673 * COMMUNICATION: None++. 00674 * 00675 * \param instance (In) Mesh instance containing the 00676 * partition. 00677 * \param partition (In) The partition being queried. 00678 * \param parts (In) The parts being queried. 00679 * \param parts_size (In) The number of parts being queried. 00680 * \param entity_type (In) Entity type of the copied 00681 * entities; 00682 * may be iBase_ALL_TYPES. 00683 * \param num_part_nbors (In/Out) Array of values specifying the 00684 * number of part neighbors for 00685 * each part in parts. 00686 * \param num_part_nbors_allocated (In/Out) Allocated size of num_part_nbors 00687 * array. 00688 * \param num_part_nbors_size (Out) Occupied size of num_part_nbors 00689 * array. 00690 * \param nbor_part_ids (In/Out) Array of part IDs for 00691 * part neighbors of part. 00692 * \param nbor_part_ids_allocated (In/Out) Allocated size of nbor_part_ids 00693 * array. 00694 * \param nbor_part_ids_size (Out) Occupied size of nbor_part_ids 00695 * array. 00696 * \param err (Out) Error code. 00697 */ 00698 void iMeshP_getPartNborsArr( iMesh_Instance instance, 00699 const iMeshP_PartitionHandle partition, 00700 const iMeshP_PartHandle* parts, 00701 const int parts_size, 00702 int entity_type, 00703 int** num_part_nbors, 00704 int* num_part_nbors_allocated, 00705 int* num_part_nbors_size, 00706 iMeshP_Part** nbor_part_ids, 00707 int* nbor_part_ids_allocated, 00708 int* nbor_part_ids_size, 00709 int* err ); 00710 00711 /** \brief Return the number of entities on a part boundary. 00712 * 00713 * Given a partition handle, a part handle, an entity type and topology, and a 00714 * target part ID, return the number of entities of the given type and/or 00715 * topology on the part boundary shared with the target part. 00716 * 00717 * COMMUNICATION: None. 00718 * 00719 * \param instance (In) Mesh instance containing the partition. 00720 * \param partition (In) The partition being queried. 00721 * \param part (In) The part being queried. 00722 * \param entity_type (In) Entity type of the boundary entities; 00723 * may be iBase_ALL_TYPES. 00724 * \param entity_topology (In) Entity topology of the boundary entities; 00725 * may be iMesh_ALL_TOPOLOGIES. 00726 * \param target_part_id (In) Part ID with which part is sharing 00727 * the boundary entities; may be 00728 * iMeshP_ALL_PARTS. 00729 * \param num_entities (Out) Number of part boundary entities shared 00730 * by part and target_part_id. 00731 * \param err (Out) Error code. 00732 */ 00733 void iMeshP_getNumPartBdryEnts( iMesh_Instance instance, 00734 const iMeshP_PartitionHandle partition, 00735 const iMeshP_PartHandle part, 00736 int entity_type, 00737 int entity_topology, 00738 iMeshP_Part target_part_id, 00739 int* num_entities, 00740 int* err ); 00741 00742 /** \brief Return the entity handles of entities on a part boundary. 00743 * 00744 * Given a partition handle, a part handle, an entity type and topology, and a 00745 * target part ID, return the entity handles of entities of the given type 00746 * and/or topology on the part boundary shared with the target part. 00747 * 00748 * COMMUNICATION: None. 00749 * 00750 * \param instance (In) Mesh instance containing the 00751 * partition. 00752 * \param partition (In) The partition being queried. 00753 * \param part (In) The part being queried. 00754 * \param entity_type (In) Entity type of the boundary 00755 * entities; 00756 * may be iBase_ALL_TYPES. 00757 * \param entity_topology (In) Entity topology of the boundary 00758 * entities; 00759 * may be iMesh_ALL_TOPOLOGIES. 00760 * \param target_part_id (In) Part ID with which part 00761 * is sharing the boundary entities; 00762 * may be iMeshP_ALL_PARTS. 00763 * \param entities (In/Out) Array of entity handles for 00764 * entities on the part boundary 00765 * between part and 00766 * target_part_id. 00767 * \param entities_allocated (In/Out) Allocated size of entities 00768 * array. 00769 * \param entities_size (Out) Occupied size of entities 00770 * array. 00771 * \param err (Out) Error code. 00772 */ 00773 void iMeshP_getPartBdryEnts( iMesh_Instance instance, 00774 const iMeshP_PartitionHandle partition, 00775 const iMeshP_PartHandle part, 00776 int entity_type, 00777 int entity_topology, 00778 iMeshP_Part target_part_id, 00779 iBase_EntityHandle** entities, 00780 int* entities_allocated, 00781 int* entities_size, 00782 int* err ); 00783 00784 /** \brief Initialize an iterator over a specified part boundary. 00785 * 00786 * Given a partition handle, a part handle, and a 00787 * target part ID, return an iterator over all entities of a given 00788 * entity type and topology along 00789 * the part boundary shared with the target part. 00790 * Iterator functionality for getNext, reset, and end is 00791 * provided through the regular iMesh iterator functions 00792 * iMesh_getNextEntIter, iMesh_resetEntIter, and iMesh_endEntIter, 00793 * respectively. 00794 * 00795 * COMMUNICATION: None. 00796 * 00797 * \param instance (In) Mesh instance containing the partition. 00798 * \param partition (In) The partition being queried. 00799 * \param part (In) The part being queried. 00800 * \param entity_type (In) Entity type of the boundary entities; 00801 * may be iBase_ALL_TYPES. 00802 * \param entity_topology (In) Entity topology of the boundary entities; 00803 * may be iMesh_ALL_TOPOLOGIES. 00804 * \param target_part_id (In) Part ID with which part is sharing 00805 * the boundary entities; may be 00806 * iMeshP_ALL_PARTS. 00807 * \param entity_iterator (Out) Iterator returned by the function. 00808 * \param err (Out) Error code. 00809 */ 00810 void iMeshP_initPartBdryEntIter( iMesh_Instance instance, 00811 const iMeshP_PartitionHandle partition, 00812 const iMeshP_PartHandle part, 00813 int entity_type, 00814 int entity_topology, 00815 iMeshP_Part target_part_id, 00816 iBase_EntityIterator* entity_iterator, 00817 int* err ); 00818 00819 /** \brief Initialize an array iterator over a specified part boundary. 00820 * 00821 * Given a partition handle, a part handle, and a 00822 * target part ID, return an array iterator over all entities of a given 00823 * entity type and topology along 00824 * the part boundary shared with the target part. 00825 * Iterator functionality for getNext, reset, and end is 00826 * provided through the regular iMesh iterator functions 00827 * iMesh_getNextEntArrIter, iMesh_resetEntArrIter, and iMesh_endEntArrIter, 00828 * respectively. 00829 * 00830 * COMMUNICATION: None. 00831 * 00832 * \param instance (In) Mesh instance containing the partition. 00833 * \param partition (In) The partition being queried. 00834 * \param part (In) The part being queried. 00835 * \param entity_type (In) Entity type of the boundary entities; 00836 * may be iBase_ALL_TYPES. 00837 * \param entity_topology (In) Entity topology of the boundary entities; 00838 * may be iMesh_ALL_TOPOLOGIES. 00839 * \param array_size (In) Size of chunks of handles returned for 00840 * each value of the iterator. 00841 * \param target_part_id (In) Part ID with which part is sharing 00842 * the boundary entities; may be 00843 * iMeshP_ALL_PARTS. 00844 * \param entity_iterator (Out) Iterator returned by the function. 00845 * \param err (Out) Error code. 00846 */ 00847 void iMeshP_initPartBdryEntArrIter( iMesh_Instance instance, 00848 const iMeshP_PartitionHandle partition, 00849 const iMeshP_PartHandle part, 00850 int entity_type, 00851 int entity_topology, 00852 int array_size, 00853 iMeshP_Part target_part_id, 00854 iBase_EntityArrIterator* entity_iterator, 00855 int* err ); 00856 00857 /*------------------------------------------------------------------------*/ 00858 /* Parts and Sets */ 00859 /*------------------------------------------------------------------------*/ 00860 00861 /** \brief Return the number of entities of a given type in both a part and an entity set. 00862 * 00863 * Given a part handle, an entity set handle, and an entity type, return 00864 * the number of entities of the given type that are in BOTH the given 00865 * part AND the given entity set. 00866 * This function is similar to iMesh_getNumOfType, but it also restricts 00867 * the returned data with respect to its existence in the given part. 00868 * 00869 * COMMUNICATION: None. 00870 * 00871 * \param instance (In) Mesh instance containing the partition. 00872 * \param partition (In) The partition being queried. 00873 * \param part (In) The part being queried. 00874 * \param entity_set (In) Entity set handle for the entity set 00875 * being queried; may be the root set. 00876 * \param entity_type (In) Entity type of the boundary entities; 00877 * may be iBase_ALL_TYPES. 00878 * \param num_type (Out) Number of entities of entity_type in 00879 * both part and entity_set. 00880 * \param err (Out) Error code. 00881 */ 00882 void iMeshP_getNumOfType( iMesh_Instance instance, 00883 const iMeshP_PartitionHandle partition, 00884 const iMeshP_PartHandle part, 00885 const iBase_EntitySetHandle entity_set, 00886 int entity_type, 00887 int* num_type, 00888 int* err ); 00889 00890 /** \brief Return the number of entities of a given topology in both a part and an entity set. 00891 * 00892 * Given a part handle, an entity set handle, and an entity topology, return 00893 * the number of entities of the given topology that are in BOTH the given 00894 * part AND the given entity set. 00895 * This function is similar to iMesh_getNumOfTopo, but it also restricts 00896 * the returned data with respect to its existence in the given part. 00897 * 00898 * COMMUNICATION: None. 00899 * 00900 * \param instance (In) Mesh instance containing the partition. 00901 * \param partition (In) The partition being queried. 00902 * \param part (In) The part being queried. 00903 * \param entity_set (In) Entity set handle for the entity set 00904 * being queried; may be the root set. 00905 * \param entity_topology (In) Entity topology of the boundary entities; 00906 * may be iMesh_ALL_TOPOLOGIES. 00907 * \param num_topo (Out) Number of entities of entity_topology in 00908 * both part and entity_set. 00909 * \param err (Out) Error code. 00910 */ 00911 void iMeshP_getNumOfTopo( iMesh_Instance instance, 00912 const iMeshP_PartitionHandle partition, 00913 const iMeshP_PartHandle part, 00914 const iBase_EntitySetHandle entity_set, 00915 int entity_topology, 00916 int* num_topo, 00917 int* err ); 00918 00919 /**\brief Get indexed representation of mesh or subset of mesh 00920 * 00921 * Given part handle and an entity set and optionally a type or topology, 00922 * for all entities that are in BOTH the part and the entity set, return: 00923 * - The entities in the part and set of the specified type or topology 00924 * - The entities adjacent to those entities with a specified 00925 * type, as a list of unique handles. 00926 * - For each entity in the first list, the adjacent entities, 00927 * specified as indices into the second list. 00928 * 00929 * COMMUNICATION: None. 00930 * 00931 *\param instance (In) Mesh instance containing the 00932 * partition. 00933 *\param partition (In) The partition being queried. 00934 *\param part (In) The part being queried. 00935 *\param entity_set_handle (In) The set being queried 00936 *\param entity_type_requestor (In) If not iBase_ALL_TYPES, act only 00937 * on the subset of entities with 00938 * the specified type. 00939 *\param entity_topology_requestor (In) If not iMesh_ALL_TOPOLOGIES, act 00940 * only on the subset of entities with 00941 * the specified topology. 00942 *\param entity_type_requested (In) The type of the adjacent entities 00943 * to return. 00944 *\param entity_handles (In/Out) The handles of the (non-strict) 00945 * subset of the union of the part 00946 * and entity set, and the optional 00947 * type and topology filtering 00948 * arguments. 00949 *\param adj_entity_handles (In/Out) The union of the entities of type 00950 * 'requested_entity_type' adjacent 00951 * to each entity in 'entity_handles'. 00952 *\param adj_entity_indices (In/Out) For each entity in 'entity_handles', 00953 * the adjacent entities of type 00954 * 'entity_type_requested', specified as 00955 * indices into 'adj_entity_handles'. 00956 * The indices are concatenated into a 00957 * single array in the order of the 00958 * entity handles in 'entity_handles'. 00959 *\param offset (In/Out) For each entity in the 00960 * corresponding position in 00961 * 'entity_handles', the position 00962 * in 'adj_entity_indices' at which 00963 * values for that entity are stored. 00964 */ 00965 void iMeshP_getAdjEntIndices( iMesh_Instance instance, 00966 iMeshP_PartitionHandle partition, 00967 iMeshP_PartHandle part, 00968 iBase_EntitySetHandle entity_set_handle, 00969 int entity_type_requestor, 00970 int entity_topology_requestor, 00971 int entity_type_requested, 00972 iBase_EntityHandle** entity_handles, 00973 int* entity_handles_allocated, 00974 int* entity_handles_size, 00975 iBase_EntityHandle** adj_entity_handles, 00976 int* adj_entity_handles_allocated, 00977 int* adj_entity_handles_size, 00978 int** adj_entity_indices, 00979 int* adj_entity_indices_allocated, 00980 int* adj_entity_indices_size, 00981 int** offset, 00982 int* offset_allocated, 00983 int* offset_size, 00984 int* err ); 00985 00986 /** \brief Return entities in a both given part and entity set. 00987 * 00988 * Given an entity set handle 00989 * and a part handle, return entity handles for entities 00990 * that are in both the part and the entity set. 00991 * This function is similar to iMesh_getEntities, but it also restricts 00992 * the returned data with respect to its existence in the given part. 00993 * 00994 * COMMUNICATION: None. 00995 * 00996 * \param instance (In) Mesh instance containing the 00997 * partition. 00998 * \param partition (In) The partition being queried. 00999 * \param part (In) The part being queried. 01000 * \param entity_set (In) Entity set handle for the 01001 * entity set being queried; 01002 * may be the root set. 01003 * \param entity_type (In) Entity type of the 01004 * entities; 01005 * may be iBase_ALL_TYPES. 01006 * \param entity_topology (In) Entity topology of the 01007 * entities; 01008 * may be iMesh_ALL_TOPOLOGIES. 01009 * \param entities (In/Out) Array of entity handles for 01010 * entities in both part 01011 * and entity_set. 01012 * \param entities_allocated (In/Out) Allocated size of entities. 01013 * \param entities_size (Out) Occupied size of entities. 01014 * \param err (Out) Error code. 01015 */ 01016 void iMeshP_getEntities( iMesh_Instance instance, 01017 const iMeshP_PartitionHandle partition, 01018 const iMeshP_PartHandle part, 01019 const iBase_EntitySetHandle entity_set, 01020 int entity_type, 01021 int entity_topology, 01022 iBase_EntityHandle** entities, 01023 int* entities_allocated, 01024 int* entities_size, 01025 int* err ); 01026 01027 /** \brief Return entities adjacent to entities in a given part and entity set. 01028 * 01029 * Given an entity set handle 01030 * and a part handle, return entities adjacent (with respect to a given 01031 * entity type and/or topology) to entities 01032 * that are in both the part and the entity set. 01033 * This function is similar to iMesh_getAdjEntities, but it also restricts 01034 * the returned data with respect to its existence in the given part. 01035 * If a non-root entity set is specified, the function also returns 01036 * flags indicating whether each adjacent entity 01037 * is in the entity set; (*in_entity_set)[i]=1 indicates that adjacent entity 01038 * (*adj_entities)[i] is in the specified entity set. 01039 * Array entry offset[i] stores the index of first adjacent entity to 01040 * entity i. 01041 * 01042 * COMMUNICATION: None. 01043 * 01044 * \param instance (In) Mesh instance containing the 01045 * partition. 01046 * \param partition (In) The partition being queried. 01047 * \param part (In) The part being queried. 01048 * \param entity_set (In) Entity set handle for the 01049 * entity set being queried; 01050 * may be the root set. 01051 * \param entity_type_requestor (In) Return entities adjacent to 01052 * entities of this type; 01053 * may be iBase_ALL_TYPES. 01054 * \param entity_topology_requestor (In) Return entities adjacent to 01055 * entities of this topology; 01056 * may be iMesh_ALL_TOPOLOGIES. 01057 * \param entity_type_requested (In) Return adjacent entities of 01058 * this type; 01059 * may be iBase_ALL_TYPES. 01060 * \param adj_entities (In/Out) Array of adjacent entity 01061 * handles returned. 01062 * \param adj_entities_allocated (In/Out) Allocated size of 01063 * adj_entities. 01064 * \param adj_entities_size (Out) Occupied size of 01065 * adj_entities. 01066 * \param offset (In/Out) Array of offsets returned. 01067 * \param offset_allocated (In/Out) Allocated size of offset. 01068 * \param offset_size (Out) Occupied size of offset. 01069 * \param in_entity_set (In/Out) Array of flags returned if 01070 * non-root entity set was input; 01071 * (*in_entity_set)[i]=1 01072 * indicates 01073 * (*adj_entities)[i] 01074 * is in the entity set. 01075 * \param in_entity_set_allocated (In/Out) Allocated size of 01076 * in_entity_set. 01077 * \param in_entity_set_size (Out) Occupied size of 01078 * in_entity_set. 01079 * \param err (Out) Error code. 01080 */ 01081 void iMeshP_getAdjEntities( iMesh_Instance instance, 01082 const iMeshP_PartitionHandle partition, 01083 const iMeshP_PartHandle part, 01084 const iBase_EntitySetHandle entity_set, 01085 int entity_type_requestor, 01086 int entity_topology_requestor, 01087 int entity_type_requested, 01088 iBase_EntityHandle** adj_entities, 01089 int* adj_entities_allocated, 01090 int* adj_entities_size, 01091 int** offset, 01092 int* offset_allocated, 01093 int* offset_size, 01094 int** in_entity_set, 01095 int* in_entity_set_allocated, 01096 int* in_entity_set_size, 01097 int* err ); 01098 01099 /** \brief Create an entity iterator for a given part and entity set. 01100 01101 * Given a local part and an entity set, return an iterator over the 01102 * entities of the requested type and topology that are in both the 01103 * part and the entity set. 01104 * Iterator functionality for getNext, reset, and end is 01105 * provided through the regular iMesh iterator functions 01106 * iMesh_getNextEntIter, iMesh_resetEntIter, and iMesh_endEntIter, 01107 * respectively. 01108 * 01109 * COMMUNICATION: None. 01110 * 01111 * \param instance (In) Mesh instance containing the 01112 * partition. 01113 * \param partition (In) The partition being queried. 01114 * \param part (In) The part being queried. 01115 * \param entity_set (In) Entity set handle for the 01116 * entity set being queried. 01117 * \param requested_entity_type (In) Type of entities to include in 01118 * the iterator. 01119 * \param requested_entity_topology (In) Topology of entities to include 01120 * in the iterator. 01121 * \param entity_iterator (Out) Iterator returned from function. 01122 * \param err (Out) Error code. 01123 */ 01124 void iMeshP_initEntIter( iMesh_Instance instance, 01125 const iMeshP_PartitionHandle partition, 01126 const iMeshP_PartHandle part, 01127 const iBase_EntitySetHandle entity_set, 01128 const int requested_entity_type, 01129 const int requested_entity_topology, 01130 iBase_EntityIterator* entity_iterator, 01131 int* err ); 01132 01133 /** \brief Create an entity array iterator for a given part and entity set. 01134 01135 * Given a local part and an entity set, return an array iterator over the 01136 * entities of the requested type and topology that are in both the 01137 * part and the entity set. 01138 * Iterator functionality for getNext, reset, and end is 01139 * provided through the regular iMesh iterator functions 01140 * iMesh_getNextEntArrIter, iMesh_resetEntArrIter, and iMesh_endEntArrIter, 01141 * respectively. 01142 * 01143 * COMMUNICATION: None. 01144 * 01145 * \param instance (In) Mesh instance containing the 01146 * partition. 01147 * \param partition (In) The partition being queried. 01148 * \param part (In) The part being queried. 01149 * \param entity_set (In) Entity set handle for the 01150 * entity set being queried. 01151 * \param requested_entity_type (In) Type of entities to include in 01152 * the iterator. 01153 * \param requested_entity_topology (In) Topology of entities to include 01154 * in the iterator. 01155 * \param requested_array_size (In) The number of handles returned 01156 * in each value of the iterator. 01157 * \param entArr_iterator (Out) Iterator returned from function. 01158 * \param err (Out) Error code. 01159 */ 01160 void iMeshP_initEntArrIter( iMesh_Instance instance, 01161 const iMeshP_PartitionHandle partition, 01162 const iMeshP_PartHandle part, 01163 const iBase_EntitySetHandle entity_set, 01164 const int requested_entity_type, 01165 const int requested_entity_topology, 01166 const int requested_array_size, 01167 iBase_EntityArrIterator* entArr_iterator, 01168 int* err ); 01169 01170 /*------------------------------------------------------------------------*/ 01171 /*------------------------------------------------------------------------*/ 01172 /* Entity Functionality */ 01173 /*------------------------------------------------------------------------*/ 01174 /*------------------------------------------------------------------------*/ 01175 01176 /** \brief Return the part ID of the part owning an entity. 01177 * 01178 * Given an entity handle and a partition handle, return the part ID 01179 * of the part that owns the entity. 01180 * Return an error code if an entity is not in the partition. 01181 * 01182 * COMMUNICATION: None++. 01183 * 01184 * \param instance (In) Mesh instance containing the 01185 * partition. 01186 * \param partition (In) The partition being queried. 01187 * \param entity (In) Entity whose owning part is to be 01188 * returned. 01189 * \param part_id (Out) Part ID of the part owning 01190 * the entity. 01191 * \param err (Out) Error code. 01192 */ 01193 void iMeshP_getEntOwnerPart( iMesh_Instance instance, 01194 const iMeshP_PartitionHandle partition, 01195 const iBase_EntityHandle entity, 01196 iMeshP_Part* part_id, 01197 int* err ); 01198 01199 /** \brief Return the part IDs of the parts owning the given entities. 01200 * 01201 * Given an array of entity handles and a partition handle, return for each 01202 * entity handle the part ID of the part that owns the entity. 01203 * Return an error code if an entity is not in the partition. 01204 * 01205 * COMMUNICATION: None++. 01206 * 01207 * \param instance (In) Mesh instance containing the 01208 * partition. 01209 * \param partition (In) The partition being queried. 01210 * \param entities (In) Entity whose owning part is to be 01211 * returned. 01212 * \param entities_size (In) Number of entities in 01213 * entities array. 01214 * \param part_ids (Out) Part IDs of the parts owning 01215 * the entities. 01216 * \param part_ids_allocated (In/Out) Allocated size of part_ids array. 01217 * \param part_ids_size (Out) Occupied size of part_ids array. 01218 * \param err (Out) Error code. 01219 */ 01220 void iMeshP_getEntOwnerPartArr( iMesh_Instance instance, 01221 const iMeshP_PartitionHandle partition, 01222 const iBase_EntityHandle* entities, 01223 const int entities_size, 01224 iMeshP_Part** part_ids, 01225 int* part_ids_allocated, 01226 int* part_ids_size, 01227 int* err ); 01228 01229 /** \brief Test for entity ownership with respect to a part. 01230 * 01231 * Given a partition handle, a part handle, and an entity handle, return a 01232 * flag indicating whether the entity is owned by the part. 01233 * 01234 * COMMUNICATION: None. 01235 * 01236 * \param instance (In) Mesh instance containing the partition. 01237 * \param partition (In) The partition being queried. 01238 * \param part (In) The part being queried. 01239 * \param entity (In) Entity whose ownership is being tested. 01240 * \param is_owner (Out) Flag indicating whether the given part 01241 * is the owner of the given entity. 01242 * \param err (Out) Error code. 01243 */ 01244 void iMeshP_isEntOwner( iMesh_Instance instance, 01245 const iMeshP_PartitionHandle partition, 01246 const iMeshP_PartHandle part, 01247 const iBase_EntityHandle entity, 01248 int* is_owner, 01249 int* err ); 01250 01251 /** \brief Test for entity ownership of many entities with respect to a part. 01252 * 01253 * Given a partition handle, a part handle, and an array of entity handles, 01254 * return for each entity handle a flag indicating whether the entity 01255 * is owned by the part. 01256 * 01257 * COMMUNICATION: None. 01258 * 01259 * \param instance (In) Mesh instance containing the 01260 * partition. 01261 * \param partition (In) The partition being queried. 01262 * \param part (In) The part being queried. 01263 * \param entities (In) Entities whose ownership is 01264 * being tested. 01265 * \param entities_size (In) Number of entity handles in 01266 * entities. 01267 * \param is_owner (Out) Flag for each entity indicating 01268 * whether the given part is the 01269 * owner of the given entity. 01270 * \param is_owner_allocated (In/Out) Allocated size of is_owner array. 01271 * \param is_owner_size (Out) Occupied size of is_owner array. 01272 * \param err (Out) Error code. 01273 */ 01274 void iMeshP_isEntOwnerArr( iMesh_Instance instance, 01275 const iMeshP_PartitionHandle partition, 01276 const iMeshP_PartHandle part, 01277 const iBase_EntityHandle* entities, 01278 const int entities_size, 01279 int** is_owner, 01280 int* is_owner_allocated, 01281 int* is_owner_size, 01282 int* err ); 01283 01284 /** \brief Return entity status (Internal, boundary, ghost). 01285 * 01286 * Given a partition handle, a part handle, and an entity handle, return a 01287 * flag indicating whether the entity is strictly internal, is on a 01288 * part boundary, or is a ghost with respect to the given part. 01289 * The returned value is a member of the iMeshP_EntStatus enumerated type. 01290 * 01291 * COMMUNICATION: None. 01292 * 01293 * \param instance (In) Mesh instance containing the partition. 01294 * \param partition (In) The partition being queried. 01295 * \param part (In) The part being queried. 01296 * \param entity (In) Entity whose status is being tested. 01297 * \param par_status (Out) Value indicating the status of the 01298 * is the entity with respect to the part. 01299 * \param err (Out) Error code. 01300 */ 01301 void iMeshP_getEntStatus( iMesh_Instance instance, 01302 const iMeshP_PartitionHandle partition, 01303 const iMeshP_PartHandle part, 01304 const iBase_EntityHandle entity, 01305 int* par_status, 01306 int* err ); 01307 01308 /** \brief Return entity status (Internal, boundary, ghost). 01309 * 01310 * Given a partition handle, a part handle, and an array of entity handles, 01311 * return for each entity handle a flag indicating whether the entity is 01312 * strictly internal, is on a part boundary, or is a ghost with respect 01313 * to the given part. 01314 * The returned value is a member of the iMeshP_EntStatus enumerated type. 01315 * 01316 * COMMUNICATION: None. 01317 * 01318 * \param instance (In) Mesh instance containing the 01319 * partition. 01320 * \param partition (In) The partition being queried. 01321 * \param part (In) The part being queried. 01322 * \param entities (In) Entities whose status is 01323 * being tested. 01324 * \param entities_size (In) Number of entity handles in 01325 * entities. 01326 * \param par_status (Out) Value for each entity indicating 01327 * the status of the entity with 01328 * respect to the part. 01329 * \param par_status_allocated (In/Out) Allocated size of par_status array. 01330 * \param par_status_size (Out) Occupied size of par_status array. 01331 * \param err (Out) Error code. 01332 */ 01333 01334 void iMeshP_getEntStatusArr( iMesh_Instance instance, 01335 const iMeshP_PartitionHandle partition, 01336 const iMeshP_PartHandle part, 01337 const iBase_EntityHandle* entities, 01338 const int entities_size, 01339 int** par_status, /* enum iMeshP_EntStatus */ 01340 int* par_status_allocated, 01341 int* par_status_size, 01342 int* err ); 01343 01344 /** \brief Return the number of copies of an entity that exist in the partition. 01345 * 01346 * Given a partition handle and an entity handle, return the number 01347 * of copies of the entity in the partition. 01348 * If the given entity is an owned entity or boundary entity, 01349 * the number of copies will be complete. 01350 * If the given entity is a ghost entity, the number of copies will be two 01351 * (the ghost and its owner). 01352 * 01353 * COMMUNICATION: None++. 01354 * 01355 * \param instance (In) Mesh instance containing the partition. 01356 * \param partition (In) The partition being queried. 01357 * \param entity (In) Entity whose copy info is requested. 01358 * \param num_copies_ent (Out) Number of copies of the entity that 01359 * exist in the partition. 01360 * \param err (Out) Error code. 01361 */ 01362 void iMeshP_getNumCopies( iMesh_Instance instance, 01363 const iMeshP_PartitionHandle partition, 01364 const iBase_EntityHandle entity, 01365 int* num_copies_ent, 01366 int* err ); 01367 01368 /** \brief Return the part IDs of parts having copies of a given entity. 01369 * 01370 * Given a partition handle and an entity handle, return the part IDs 01371 * of copies of the entity in the partition. 01372 * If the given entity is an owned entity or boundary entity, 01373 * the number of copies considered will be complete. 01374 * If the given entity is a ghost entity, the number of copies considered 01375 * will be two (the ghost and its owner). 01376 * 01377 * COMMUNICATION: None++. 01378 * 01379 * \param instance (In) Mesh instance containing the 01380 * partition. 01381 * \param partition (In) The partition being queried. 01382 * \param entity (In) Entity whose copy info 01383 * is requested. 01384 * \param part_ids (Out) Part IDs of parts having copies 01385 * of the given entity. 01386 * \param part_ids_allocated (In/Out) Allocated size of part_ids array. 01387 * \param part_ids_size (Out) Occupied size of part_ids array. 01388 * \param err (Out) Error code. 01389 */ 01390 void iMeshP_getCopyParts( iMesh_Instance instance, 01391 const iMeshP_PartitionHandle partition, 01392 const iBase_EntityHandle entity, 01393 iMeshP_Part** part_ids, 01394 int* part_ids_allocated, 01395 int* part_ids_size, 01396 int* err ); 01397 01398 /** \brief Get (remote) entity handles of copies of a given entity. 01399 * 01400 * Given a partition handle and an entity handle, return (remote) entity 01401 * handles and part IDs of all copies of the entity. 01402 * If the given entity is an owned entity or boundary entity, 01403 * the number of copies considered will be complete. 01404 * If the given entity is a ghost entity, the number of copies considered 01405 * will be two (the ghost and its owner). 01406 * 01407 * COMMUNICATION: None++. 01408 * 01409 * \param instance (In) Mesh instance containing the 01410 * partition. 01411 * \param partition (In) The partition being queried. 01412 * \param entity (In) Entity whose copy info 01413 * is requested. 01414 * \param part_ids (Out) Part IDs of parts having copies 01415 * of the given entity. 01416 * \param part_ids_allocated (In/Out) Allocated size of part_ids array. 01417 * \param part_ids_size (Out) Occupied size of part_ids array. 01418 * \param copies (Out) (Remote) entity handles of the 01419 * entity copies. 01420 * \param copies_allocated (In/Out) Allocated size of copies. 01421 * \param copies_size (Out) Occupied size of copies. 01422 * \param err (Out) Error code. 01423 */ 01424 void iMeshP_getCopies( iMesh_Instance instance, 01425 const iMeshP_PartitionHandle partition, 01426 const iBase_EntityHandle entity, 01427 iMeshP_Part** part_ids, 01428 int* part_ids_allocated, 01429 int* part_ids_size, 01430 iBase_EntityHandle** copies, 01431 int* copies_allocated, 01432 int* copies_size, 01433 int* err ); 01434 01435 /** \brief Get the entity handle of a copy of a given entity in a given part. 01436 * 01437 * Given a partition handle, an entity handle and a part ID, 01438 * return the (remote) entity handle of the copy of the entity in that part. 01439 * Return an error if the entity does not exist in the specified part. 01440 * 01441 * COMMUNICATION: None++. 01442 * 01443 * \param instance (In) Mesh instance containing the 01444 * partition. 01445 * \param partition (In) The partition being queried. 01446 * \param entity (In) Entity whose copy info 01447 * is requested. 01448 * \param part_id (In) Part ID of part whose copy 01449 * of the given entity is requested. 01450 * \param copy_entity (Out) (Remote) entity handle of the 01451 * entity copy from the given part. 01452 * \param err (Out) Error code. 01453 */ 01454 void iMeshP_getCopyOnPart( iMesh_Instance instance, 01455 const iMeshP_PartitionHandle partition, 01456 const iBase_EntityHandle entity, 01457 const iMeshP_Part part_id, 01458 iBase_EntityHandle* copy_entity, 01459 int* err ); 01460 01461 /** \brief Get the entity handle of a copy of a given entity in its owner part. 01462 * 01463 * Given a partition handle and an entity handle, return the (remote) 01464 * entity handle of the copy of the entity in its owner part. 01465 * 01466 * COMMUNICATION: None++. 01467 * 01468 * \param instance (In) Mesh instance containing the 01469 * partition. 01470 * \param partition (In) The partition being queried. 01471 * \param entity (In) Entity whose copy info 01472 * is requested. 01473 * \param owner_part_id (Out) Part ID of the entity's owner part. 01474 * \param owner_entity (Out) (Remote) entity handle of the 01475 * entity copy from the owner part. 01476 * \param err (Out) Error code. 01477 */ 01478 void iMeshP_getOwnerCopy( iMesh_Instance instance, 01479 const iMeshP_PartitionHandle partition, 01480 const iBase_EntityHandle entity, 01481 iMeshP_Part* owner_part_id, 01482 iBase_EntityHandle* owner_entity, 01483 int* err ); 01484 01485 /*------------------------------------------------------------------------*/ 01486 /*------------------------------------------------------------------------*/ 01487 /*------- COMMUNICATION ----------*/ 01488 /*------------------------------------------------------------------------*/ 01489 /*------------------------------------------------------------------------*/ 01490 01491 /**\brief Wait for a specific iMeshP request to complete. 01492 * 01493 * Given an iMeshP_RequestHandle, wait for the request to complete. 01494 * 01495 * COMMUNICATION: Blocking point-to-point. 01496 * 01497 * \param instance (In) Mesh instance containing the 01498 * partition. 01499 * \param partition (In) The partition being queried. 01500 * \param request (In) iMeshP request for whose completion 01501 * we should wait. 01502 * \param err (Out) Error code. 01503 */ 01504 void iMeshP_waitForRequest( iMesh_Instance instance, 01505 const iMeshP_PartitionHandle partition, 01506 iMeshP_RequestHandle request, 01507 int* err ); 01508 01509 /**\brief Wait for any of the specified iMeshP requests to complete. 01510 * 01511 * Given an array of iMeshP_RequestHandles, wait for any one of the requests 01512 * to complete. 01513 * 01514 * COMMUNICATION: Blocking point-to-point. 01515 * 01516 * \param instance (In) Mesh instance containing the 01517 * partition. 01518 * \param partition (In) The partition being queried. 01519 * \param requests (In) iMeshP requests for which we wait 01520 * until one request completes. 01521 * \param requests_size (In) Number of requests in requests. 01522 * \param index (Out) Index of the request that completed. 01523 * \param err (Out) Error code. 01524 */ 01525 void iMeshP_waitForAnyRequest( iMesh_Instance instance, 01526 const iMeshP_PartitionHandle partition, 01527 iMeshP_RequestHandle* requests, 01528 int requests_size, 01529 int* index, 01530 int* err ); 01531 01532 /**\brief Wait for all of the specified iMeshP requests to complete. 01533 * 01534 * Given an array of iMeshP_RequestHandles, wait for all of the requests 01535 * to complete. 01536 * 01537 * COMMUNICATION: Blocking point-to-point. 01538 * 01539 * \param instance (In) Mesh instance containing the 01540 * partition. 01541 * \param partition (In) The partition being queried. 01542 * \param requests (In) iMeshP requests for which we wait 01543 * until completion. 01544 * \param requests_size (In) Number of requests in requests. 01545 * \param err (Out) Error code. 01546 */ 01547 void iMeshP_waitForAllRequests( iMesh_Instance instance, 01548 const iMeshP_PartitionHandle partition, 01549 iMeshP_RequestHandle* requests, 01550 int requests_size, 01551 int* err ); 01552 01553 /**\brief Wait for a specific request to complete; return entities received. 01554 * 01555 * Given an iMeshP_RequestHandle, wait for the request to complete. Return 01556 * entities for which information was received. 01557 * 01558 * COMMUNICATION: Blocking point-to-point. 01559 * 01560 * \param instance (In) Mesh instance containing the 01561 * partition. 01562 * \param partition (In) The partition being queried. 01563 * \param request (In) iMeshP request for whose completion 01564 * we should wait. 01565 * \param out_entities (Out) Entities for which information was 01566 * received. 01567 * \param out_entities_allocated (In/Out) Allocated size of out_entities. 01568 * \param out_entities_size (Out) Occupied size of out_entities. 01569 * \param err (Out) Error code. 01570 */ 01571 void iMeshP_waitForRequestEnt( iMesh_Instance instance, 01572 const iMeshP_PartitionHandle partition, 01573 iMeshP_RequestHandle request, 01574 iBase_EntityHandle** out_entities, 01575 int* out_entities_allocated, 01576 int* out_entities_size, 01577 int* err ); 01578 01579 /**\brief Test whether a specific request has completed. 01580 * 01581 * Given an iMeshP_RequestHandle, test whether the request has completed. 01582 * This function will not wait until the request completes; it will only 01583 * return the completion status (complete = 1 or 0). 01584 * 01585 * COMMUNICATION: None. 01586 * 01587 * \param instance (In) Mesh instance containing the 01588 * partition. 01589 * \param partition (In) The partition being queried. 01590 * \param request (In) iMeshP request for whose completion 01591 * we should test. 01592 * \param completed (Out) Flag indicating whether (1) or 01593 * not (0) the given request has 01594 * completed. 01595 * \param err (Out) Error code. 01596 */ 01597 void iMeshP_testRequest( iMesh_Instance instance, 01598 const iMeshP_PartitionHandle partition, 01599 iMeshP_RequestHandle request, 01600 int* completed, 01601 int* err ); 01602 01603 /** \brief Poll for outstanding requests. 01604 * 01605 * Check for outstanding requests from other parts, handle any requests 01606 * found, and return an array of requests that have been handled. If 01607 * the array has a size allocated already, then the implementation stops 01608 * working when it has generated that many completed requests, even if there 01609 * are more requests waiting. 01610 * 01611 * COMMUNICATION: non-blocking; point-to-point. 01612 * 01613 * \param instance (In) Mesh instance containing the 01614 * partition. 01615 * \param partition (In) The partition being queried. 01616 * \param requests_completed (Out) Requests that were completed. 01617 * \param requests_completed_allocated (In/Out) Allocated size of 01618 * requests_completed. 01619 * \param requests_completed_size (Out) Occupied size of 01620 * requests_completed. 01621 * \param err (Out) Error code. 01622 */ 01623 void iMeshP_pollForRequests( iMesh_Instance instance, 01624 iMeshP_PartitionHandle partition, 01625 iMeshP_RequestHandle** requests_completed, 01626 int* requests_completed_allocated, 01627 int* requests_completed_size, 01628 int* err ); 01629 01630 /*-------------------------------------------------------------------- 01631 ------- Requests for off-processor mesh modification ------- 01632 --------------------------------------------------------------------*/ 01633 01634 /** \brief Add entities to on-process and/or off-process parts. 01635 * 01636 * Given a partition and a list of entities, add those entities to the 01637 * target parts. The entities can be added as copies or migrated entirely 01638 * (i.e., change ownership of the entities) 01639 * to the parts. The entities' downward adjacencies are also copied and/or 01640 * migrated as appropriate to support the entities. 01641 * This function is a collective, non-blocking operation 01642 * to be called by all processes in the partition's communicator. 01643 * An iMeshP_RequestHandle is returned; any of the 01644 * iMeshP_wait* functions can be used to block until the request is completed. 01645 * 01646 * COMMUNICATION: Collective. Non-blocking. 01647 * 01648 * \param instance (In) Mesh instance containing the partition. 01649 * \param partition (In) Handle for the partition being queried. 01650 * \param entities (In) Entities to be sent. 01651 * \param entities_size (In) Number of entities to be sent. 01652 * \param target_part_ids (In) Array of size entities_size listing 01653 * the parts to which the entities should 01654 * be sent. 01655 * \param command_code (In) Flag indicating whether to migrate 01656 * the entities or only make copies. 01657 * \param update_ghost (In) Flag indicating whether (1) or not (0) 01658 * ghost copies of the entities should be 01659 * updated with new owner information. 01660 * \param request (Out) iMeshP RequestHandle returned; can be used 01661 * for blocking until this send is complete. 01662 * \param err (Out) Error code. 01663 */ 01664 void iMeshP_exchEntArrToPartsAll( iMesh_Instance instance, 01665 const iMeshP_PartitionHandle partition, 01666 const iBase_EntityHandle* entities, 01667 const int entities_size, 01668 const iMeshP_Part* target_part_ids, 01669 int command_code, 01670 int update_ghost, 01671 iMeshP_RequestHandle* request, 01672 int* err ); 01673 01674 /** \brief Request in-migration of an entity and its upward adjacencies. 01675 * 01676 * This function is a "pull" migration, where a part requests to become the 01677 * owner of an entity that is owned by another part (so that the part has 01678 * the right to modify the entity). The requested 01679 * entity must be on the part boundary and is identified by a local handle 01680 * (i.e., an entity part-boundary copy). This operation may require multiple 01681 * rounds of communication, and at some times, certain entities may be 01682 * locked (unavailable for local modification) while info about their 01683 * remote copies is still in question. Tags and parallel set membership 01684 * are migrated as well as the appropriate adjacency info. 01685 * An iMeshP request handle is returned. 01686 * 01687 * COMMUNICATION: point-to-point, non-blocking, pull. 01688 * 01689 * \param instance (In) Mesh instance containing the partition. 01690 * \param partition (In) The partition being queried. 01691 * \param part (In) The part to which the entity is migrated. 01692 * \param local_entity (In) The local entity copy for the entity to be 01693 * migrated. 01694 * \param request (Out) The iMeshP request handle returned. 01695 * \param err (Out) Error code. 01696 */ 01697 void iMeshP_migrateEntity( iMesh_Instance instance, 01698 const iMeshP_PartitionHandle partition, 01699 iMeshP_PartHandle part, 01700 iBase_EntityHandle local_entity, 01701 iMeshP_RequestHandle* request, 01702 int* err ); 01703 01704 /** \brief Update vertex coordinates for vertex copies. 01705 * 01706 * For a given vertex, update its copies with the vertex's coordinates. 01707 * This function assumes that a local vertex's coordinates were updated 01708 * through a call to iMesh_setVtxCoords. This function then updates all 01709 * copies of the vertex with the updated coordinates. 01710 * The communication here is push-and-forget; as such, 01711 * no request handle needs to be returned. 01712 * 01713 * COMMUNICATION: point-to-point, non-blocking, push-and-forget. 01714 * 01715 * \param instance (In) Mesh instance containing the partition. 01716 * \param partition (In) The partition being queried. 01717 * \param local_vertex (In) The vertex whose copies should be updated. 01718 * \param err (Out) Error code. 01719 */ 01720 void iMeshP_updateVtxCoords( iMesh_Instance instance, 01721 const iMeshP_PartitionHandle partition, 01722 const iBase_EntityHandle local_vertex, 01723 int* err ); 01724 01725 /** \brief Replace entities on the part boundary. 01726 * 01727 * This function performs changes on the part boundary where the 01728 * calling application can ensure that things are done 01729 * identically on both sides and that the arguments are passed in an order 01730 * that can be matched. (Specifically, matching new entities should appear in 01731 * the same order in the call array.) An example is creation of new 01732 * boundary edges during edge splitting. 01733 * Communication here could be a 01734 * two-way push-and-forget, or some variant on push-and-confirm. 01735 * CHANGES: At Onkar's suggestion, added an offset array (similar to array 01736 * adjacency requests) so that a single call can easily handle coordination 01737 * with multiple entities on part-boundary. 01738 * 01739 * COMMUNICATION: point-to-point, non-blocking, push-and-forget. 01740 * 01741 * \param instance (In) Mesh instance containing the partition. 01742 * \param partition (In) The partition being queried. 01743 * \param old_entities (In) The entities to be replaced. 01744 * \param old_entities_size (In) The number of entities to be replaced. 01745 * \param new_entities (In) The entities that replace the old entities. 01746 * \param new_entities_size (In) The number of entities in new_entities. 01747 * \param offset (In) Index into new_entities; old_entities[i] 01748 * is replaced by new_entities[offset[i]] to 01749 * new_entities[offset[i+1]-1]. 01750 * \param offset_size (In) The number of entries in offset. 01751 * \param err (Out) Error code. 01752 */ 01753 void iMeshP_replaceOnPartBdry( iMesh_Instance instance, 01754 const iMeshP_PartitionHandle partition, 01755 const iBase_EntityHandle* old_entities, 01756 const int old_entities_size, 01757 const iBase_EntityHandle* new_entities, 01758 const int new_entities_size, 01759 const int* offset, 01760 const int offset_size, 01761 int* err ); 01762 01763 /** \brief Push ghost copies of individual entities onto other parts. 01764 * 01765 * Given an entity and a target part, create a ghost copy of the entity on 01766 * the target part. 01767 * 01768 * Communication here is push-and-confirm (so that the original knows remote 01769 * entity handle of the created ghosts). The closure of a new ghost is pushed 01770 * automatically as part of the underlying communication. 01771 * 01772 * COMMUNICATION: point-to-point, non-blocking, push. 01773 * 01774 * \param instance (In) Mesh instance containing the partition. 01775 * \param partition (In) The partition being queried. 01776 * \param target_part_id (In) The part to receive the new ghost. 01777 * \param entity_to_copy (In) The entity to be copied in target_part_id. 01778 * \param request (Out) The iMeshP request handle returned. 01779 * \param err (Out) Error code. 01780 */ 01781 void iMeshP_addGhostOf( iMesh_Instance instance, 01782 const iMeshP_PartitionHandle partition, 01783 const iMeshP_Part target_part_id, 01784 iBase_EntityHandle entity_to_copy, 01785 iMeshP_RequestHandle* request, 01786 int* err ); 01787 01788 /** \brief Remove ghost copies of individual entities from other parts. 01789 * 01790 * Given an entity and a target part, remove the ghost copy of the entity on 01791 * the target part. 01792 * 01793 * Communication is push-and-forget; as such, no request handle is needed. 01794 * The remote part will clean up the closure of the removed ghost 01795 * as appropriate during deletion. 01796 * 01797 * COMMUNICATION: point-to-point, non-blocking, push-and-forget. 01798 * 01799 * \param instance (In) Mesh instance containing the partition. 01800 * \param partition (In) The partition being queried. 01801 * \param target_part_id (In) The part to lose the ghost. 01802 * \param copy_to_purge (In) The entity whose ghost is removed from 01803 * target_part_id. 01804 * \param err (Out) Error code. 01805 */ 01806 void iMeshP_rmvGhostOf( iMesh_Instance instance, 01807 const iMeshP_PartitionHandle partition, 01808 const iMeshP_Part target_part_id, 01809 iBase_EntityHandle copy_to_purge, 01810 int* err ); 01811 01812 /** \brief Indicate completion of mesh modification. 01813 * 01814 * Calling this function indicates that the user is finished with mesh 01815 * modification for now. With mesh modification complete, the implementation 01816 * can update ghost, partition, boundary, and other information to 01817 * re-establish a valid distributed mesh. This function waits for all 01818 * message traffic to clear and rebuilds ghost information that was 01819 * allowed to go obsolete during mesh modification. 01820 * 01821 * COMMUNICATION: collective. 01822 * 01823 * \param instance (In) Mesh instance containing the partition. 01824 * \param partition (In) The partition being queried. 01825 * \param err (Out) Error code. 01826 */ 01827 void iMeshP_syncMeshAll( iMesh_Instance instance, iMeshP_PartitionHandle partition, int* err ); 01828 01829 /*--------------------------------------------------------------------------*/ 01830 /* Functions to send Tag data from owning entities to copies. */ 01831 /*--------------------------------------------------------------------------*/ 01832 01833 /**\brief Synchronously send tag data for given entity types and topologies. 01834 * 01835 * Send tag information for shared entities of specified type and 01836 * topology. The tag data is "pushed" from the owner entities to all copies. 01837 * This version operates on all shared entities of specified type and topology 01838 * (or all types/topologies if iBase_ALL_TYPES/iMesh_ALL_TOPOLOGIES are 01839 * given). This function assumes tag handles given on various 01840 * calling parts are consistent; i.e. they have the same name, 01841 * data type, size, etc. This call blocks until communication is 01842 * completed. 01843 * 01844 * COMMUNICATION: point-to-point, blocking. 01845 * 01846 * \param instance (In) Mesh instance containing the partition. 01847 * \param partition (In) The partition being queried. 01848 * \param source_tag (In) Tag handle for the sending entities. 01849 * \param dest_tag (In) Tag handle for the receiving entities. 01850 * \param entity_type (In) Tag data is exchanged only for this 01851 * entity type. 01852 * \param entity_topo (In) Tag data is exchanged only for this 01853 * entity topology. 01854 * \param err (Out) Error code. 01855 */ 01856 void iMeshP_pushTags( iMesh_Instance instance, 01857 const iMeshP_PartitionHandle partition, 01858 iBase_TagHandle source_tag, 01859 iBase_TagHandle dest_tag, 01860 int entity_type, 01861 int entity_topo, 01862 int* err ); 01863 01864 /**\brief Synchronously send tag data for individual entities. 01865 * 01866 * Send tag information for the specified entities. 01867 * The tag data is "pushed" from the owner entities to all copies. 01868 * This function assumes tag handles given on various 01869 * calling parts are consistent; i.e. they have the same name, 01870 * data type, size, etc. This call blocks until communication is 01871 * completed. 01872 * 01873 * COMMUNICATION: point-to-point, blocking. 01874 * 01875 * \param instance (In) Mesh instance containing the partition. 01876 * \param partition (In) The partition being queried. 01877 * \param source_tag (In) Tag handle for the sending entities. 01878 * \param dest_tag (In) Tag handle for the receiving entities. 01879 * \param entities (In) Owned entities for which to send data. 01880 * \param entities_size (In) The number of entities for which to send data. 01881 * \param err (Out) Error code. 01882 */ 01883 void iMeshP_pushTagsEnt( iMesh_Instance instance, 01884 const iMeshP_PartitionHandle partition, 01885 iBase_TagHandle source_tag, 01886 iBase_TagHandle dest_tag, 01887 const iBase_EntityHandle* entities, 01888 int entities_size, 01889 int* err ); 01890 01891 /**\brief Asynchronously send tag data for given entity types and topologies. 01892 * 01893 * Send tag information for shared entities of specified type and 01894 * topology. The tag data is "pushed" from the owner entities to all copies. 01895 * This version operates on all shared entities of specified type and topology 01896 * (or all types/topologies if iBase_ALL_TYPES/iMesh_ALL_TOPOLOGIES are 01897 * given). This function assumes tag handles given on various 01898 * calling parts are consistent; i.e. they have the same name, 01899 * data type, size, etc. 01900 * This call does not block; applications should call 01901 * iMeshP_waitForRequest (or a similar wait function) 01902 * to block until this push is completed. 01903 * 01904 * COMMUNICATION: point-to-point, non-blocking. 01905 * 01906 * \param instance (In) Mesh instance containing the partition. 01907 * \param partition (In) The partition being queried. 01908 * \param source_tag (In) Tag handle for the sending entities. 01909 * \param dest_tag (In) Tag handle for the receiving entities. 01910 * \param entity_type (In) Tag data is exchanged only for this 01911 * entity type. 01912 * \param entity_topo (In) Tag data is exchanged only for this 01913 * entity topology. 01914 * \param request (Out) The iMeshP request handle returned. 01915 * \param err (Out) Error code. 01916 */ 01917 void iMeshP_iPushTags( iMesh_Instance instance, 01918 const iMeshP_PartitionHandle partition, 01919 iBase_TagHandle source_tag, 01920 iBase_TagHandle dest_tag, 01921 int entity_type, 01922 int entity_topo, 01923 iMeshP_RequestHandle* request, 01924 int* err ); 01925 01926 /**\brief Asynchronously send tag data for individual entities. 01927 * 01928 * Send tag information for the specified entities. 01929 * The tag data is "pushed" from the owner entities to all copies. 01930 * This function assumes tag handles given on various 01931 * calling parts are consistent; i.e. they have the same name, 01932 * data type, size, etc. 01933 * This call does not block; applications should call 01934 * iMeshP_waitForRequest (or a similar wait function) 01935 * to block until this push is completed. 01936 * 01937 * COMMUNICATION: point-to-point, non-blocking. 01938 * 01939 * \param instance (In) Mesh instance containing the partition. 01940 * \param partition (In) The partition being queried. 01941 * \param source_tag (In) Tag handle for the sending entities. 01942 * \param dest_tag (In) Tag handle for the receiving entities. 01943 * \param entities (In) Owned entities for which to send data. 01944 * \param entities_size (In) The number of entities for which to send data. 01945 * \param request (Out) The iMeshP request handle returned. 01946 * \param err (Out) Error code. 01947 */ 01948 void iMeshP_iPushTagsEnt( iMesh_Instance instance, 01949 const iMeshP_PartitionHandle partition, 01950 iBase_TagHandle source_tag, 01951 iBase_TagHandle dest_tag, 01952 const iBase_EntityHandle* entities, 01953 int entities_size, 01954 iMeshP_RequestHandle* request, 01955 int* err ); 01956 01957 /*------------------------------------------------------------* 01958 * GHOSTING * 01959 *------------------------------------------------------------*/ 01960 01961 /* \brief Create ghost entities between parts. 01962 * 01963 * Ghost entities are specified similar to 2nd-order adjacencies, i.e., 01964 * through a "bridge" dimension. The number of layers is measured from 01965 * the inter-part interfaces. For example, to get two layers of region 01966 * entities in the ghost layer, measured from faces on the interface, 01967 * use ghost_dim=3, bridge_dim=2, and num_layers=2. 01968 * The number of layers specified is with respect to the global mesh; 01969 * that is, ghosting may extend beyond a single neighboring processor if the 01970 * number of layers is high. 01971 * 01972 * Ghost information is cached in the partition. 01973 * The triplet describing a ghosting "rule" (ghost dim, bridge dim, # 01974 * layers) is stored in the partition; ghosting that became incorrect 01975 * due to mesh modification or redistribution of mesh entities is 01976 * re-established using these rules by the end 01977 * of iMeshP_syncPartitionAll and iMeshP_syncMeshAll. 01978 * Implementations can choose to keep ghosting consistent throughout 01979 * mesh modification, but ghosts are not required to be consistent until 01980 * the end of these two functions. 01981 01982 * iMeshP_createGhostEntsAll is cumulative; that is, multiple calls can only 01983 * add more ghosts, not eliminate previous ghosts. 01984 * 01985 * COMMUNICATION: Collective. Blocking. 01986 * 01987 * \param instance (In) Mesh instance containing the partition. 01988 * \param partition (In) The partition in which to create ghosts. 01989 * \param ghost_type (In) Entity type of entities to be ghosted. 01990 * \param bridge_type (In) Entity type through which bridge 01991 * adjacencies are found. 01992 * \param num_layers (In) Number of layers of ghost entities. 01993 * \param include_copies (In) Flag indicating whether to create ghosts 01994 * of non-owned part boundary entities 01995 * (YES=1, NO=0). 01996 * \param err (Out) Error code. 01997 */ 01998 void iMeshP_createGhostEntsAll( iMesh_Instance instance, 01999 iMeshP_PartitionHandle partition, 02000 int ghost_type, 02001 int bridge_type, 02002 int num_layers, 02003 int include_copies, 02004 int* err ); 02005 02006 /* \brief Delete all ghost entities between parts. 02007 * 02008 * Given a partition, delete all ghost entities in that partition of the mesh. 02009 * 02010 * COMMUNICATION: Collective. Blocking. 02011 * 02012 * \param instance (In) Mesh instance containing the partition. 02013 * \param partition (In) The partition from which to delete ghosts. 02014 * \param err (Out) Error code. 02015 * 02016 */ 02017 void iMeshP_deleteGhostEntsAll( iMesh_Instance instance, iMeshP_PartitionHandle partition, int* err ); 02018 02019 /** \brief Return information about all ghosting on a partition. 02020 * 02021 * Return the ghosting rules established through calls to 02022 * iMeshP_createGhostEntsAll. 02023 * 02024 * COMMUNICATION: None. 02025 * 02026 * \param instance (In) Mesh instance containing the 02027 * partition. 02028 * \param partition (In) The partition to be queried. 02029 * \param ghost_rules_allocated (In/Out) Allocated size of ghost_type, 02030 * bridge_type and num_layers. 02031 * \param ghost_rules_size (Out) Occupied size of ghost_type, 02032 * bridge_type and num_layers; 02033 * equal to the number of ghosting 02034 * rules currently registered in 02035 * the partition. 02036 * \param ghost_type (Out) Entity type of ghost entities 02037 * for each rule. 02038 * \param bridge_type (Out) Entity type of bridge entities 02039 * for each rule. 02040 * \param num_layers (Out) Number of layers of ghosts in each 02041 * rule. 02042 * \param err (Out) Error code. 02043 */ 02044 void iMeshP_ghostEntInfo( const iMesh_Instance instance, 02045 const iMeshP_PartitionHandle partition, 02046 int* ghost_rules_allocated, 02047 int* ghost_rules_size, 02048 int** ghost_type, 02049 int** bridge_type, 02050 int** num_layers, 02051 int* err ); 02052 02053 /*-------------------------------------------------------------------------- 02054 FILE I/O 02055 --------------------------------------------------------------------------*/ 02056 /* iMeshP file I/O closely aligns with iMesh file I/O. The major 02057 * change is the addition of a iMeshP_PartitionHandle argument to both 02058 * iMeshP_loadAll and iMeshP_saveAll, enabling I/O from parallel processes. 02059 * For now, individual implementations will support different sets of 02060 * options; Tim and Ken will work to unify the options by SC08. 02061 */ 02062 02063 /** \brief Populate a mesh instance and a partition by reading data from files. 02064 * 02065 * Before calling iMeshP_loadAll, the application creates both a mesh 02066 * instance and a partition handle. iMeshP_loadAll then reads the 02067 * specified file, inserts entities into the mesh instance, constructs 02068 * parts within the partition, and inserts entities into the parts. 02069 * Options allow n>=1 files on p processes. 02070 * Optional capabilities of iMeshP_loadAll include computing an initial 02071 * partition (e.g., if a serial mesh file without part assignments is read) 02072 * and creating ghost entities as requested by the application; the 02073 * availability of these options is implementation dependent. 02074 * 02075 * COMMUNICATION: Collective. 02076 * 02077 * \param instance (In) Mesh instance to contain the data. 02078 * \param partition (In) The newly populated partition. 02079 * \param entity_set (In) Set to which the mesh will be added. 02080 * \param name (in) File name from which mesh data is read. 02081 * \param options (In) Implementation-specific options string. 02082 * \param err (Out) Error code. 02083 * \param name_len (In) Length of the file name character string. 02084 * \param options_len (In) Length of the options character string. 02085 */ 02086 void iMeshP_loadAll( iMesh_Instance instance, 02087 const iMeshP_PartitionHandle partition, 02088 const iBase_EntitySetHandle entity_set, 02089 const char* name, 02090 const char* options, 02091 int* err, 02092 int name_len, 02093 int options_len ); 02094 02095 /** \brief Write data from a mesh instance and a partition to files. 02096 * 02097 * iMeshP_saveAll writes mesh and partition data to the specified file. 02098 * Options allow n>=1 files on p processes. 02099 * 02100 * COMMUNICATION: Collective. 02101 * 02102 * \param instance (In) Mesh instance containing the partition. 02103 * \param partition (In) The partition being saved. 02104 * \param entity_set (In) Set from which data will be saved. 02105 * \param name (in) File name to which mesh data is written. 02106 * \param options (In) Implementation-specific options string. 02107 * \param err (Out) Error code. 02108 * \param name_len (In) Length of the file name character string. 02109 * \param options_len (In) Length of the options character string. 02110 */ 02111 void iMeshP_saveAll( iMesh_Instance instance, 02112 const iMeshP_PartitionHandle partition, 02113 const iBase_EntitySetHandle entity_set, 02114 const char* name, 02115 const char* options, 02116 int* err, 02117 const int name_len, 02118 int options_len ); 02119 02120 /* 02121 ------------------------------------------------ 02122 Major Items left to do: 02123 - Support for multiple partitions. 02124 We discussed designating a given partition as 02125 the "active" partition; i.e., the partition that is actually used in 02126 the distribution of mesh data in distributed memory. We were concerned 02127 that when multiple partitions were used, multiple copies of mesh 02128 entities would be needed to fully support multiple partitions at the 02129 same time. Designating one partition as "active" would store data 02130 with respect to only one partition. 02131 - File I/O support. 02132 Need common set of options to allow interoperability. 02133 Support single files, N << P files on P processes, and P files. 02134 Support reading and writing partition information. 02135 Support initial parallel partitioning of serial file data. 02136 Support storing mapping of parts to processes in files. 02137 02138 ------------------------------------------------ 02139 Minor Items left to do: 02140 - Determine which capabilities need both "getNumX" and "getX" functions. 02141 That is, when would an application need "getNumX" to allocate memory 02142 for "getX" or separately from "getX". When could we use only "getX" 02143 and return numX as a byproduct. 02144 02145 - Determine with functions need "Ent" and "EntArr" versions, or whether 02146 we should adopt only the more general "EntArr" version. 02147 02148 - Determine whether to revise iMeshP_createPartition to make it less MPI 02149 specific. We don't want to require applications to link with MPI if the 02150 implementation doesn't require it. We may define an ITAPS_Comm name 02151 typedef'ed appropriately. 02152 02153 - iMeshP_getOwnerCopy could be achieved by calling iMeshP_getOwnerPart 02154 followed by iMeshP_getCopyOnPart. Do we want to keep iMeshP_getOwnerCopy? 02155 02156 - Need function to receive tag data from part-boundary entities in owner. 02157 Possible options: return the tag data values received directly, or 02158 include a mathematical operation (similar to MPI_SUM). 9/15/08 02159 02160 ------------------------------------------------ 02161 Comments and resolved questions: 02162 02163 - Applications will build partitions by (1) creating a partition handle 02164 on each process to be included in the partition; (2) adding parts to 02165 the partition handle within the process; (3) populating the parts with 02166 entities, and (4) calling iMeshP_syncPartitionAll to allow the 02167 implementation to compute global data for the partition. 02168 02169 - For now, we will not include an iterator over local (to a 02170 process) parts within a partition. If it is needed, it can be added 02171 later. 02172 02173 - We will not provide capability to move entire parts to new 02174 processes; instead, the new process must create the part in its 02175 partition handle and then receive (perhaps in bulk) the entities to 02176 populate the part. In other words, parts can be added to only a local 02177 partition handle. 02178 02179 - Currently, iMesh doesn't have the functionality to get entities or 02180 entity sets by type and tag in serial. Should it? 02181 Many people said it would be useful; others said it could be costly 02182 (in parallel) or numerically difficult (for floating point values). 02183 This issue is an iMesh issue, not a parallel interface issue, so 02184 for this document, the issue is resolved. The resolution: If 02185 iMesh adopts this capability, we will add it to the 02186 parallel interface. 02187 02188 - We will not include functions that return all entities with 02189 given characteristics within a partition; the memory use of these 02190 functions can be large. Instead, we will return entity information 02191 with respect to parts and/or mesh instances. If the user wants such 02192 info, he should go through the mechanics of gathering it himself so 02193 that he is painfully aware of how much memory he is allocating. 02194 Removed the following global queries: 02195 + All tag names over the partition; 02196 + All entities in this partition having a given type, tag and/or 02197 tag name. 02198 + All entity sets in this partition having a given 02199 type, tag and/or tag name. 02200 02201 - We will not include functions that return information about each 02202 part and/or process in a partition. Such functions limit memory 02203 scalability for large numbers of parts. If the user wants such 02204 info, he should go through the mechanics of gathering it himself so 02205 that he is painfully aware of how much memory he is allocating. 02206 Removed the following global queries: 02207 + The number of entities in each part of the partition; 02208 + The number of entity sets in each part of the partition; 02209 + The number of entities with given type, tag, and/or 02210 tag name in each part of the partition; 02211 + The number of entity sets with given type, tag, 02212 and/or tag name in each part of the partition; 02213 + All tag names in each part of the partition; 02214 02215 - For functions that replace a set handle with a part handle, return 02216 all appropriate entities in a part, whether they are owned or are 02217 copies. The application can test for ownership if needed. 02218 02219 - Part assignments computed with respect to a set of 02220 entities induce part assignments to adjacent entities in an 02221 implementation-dependent fashion. That is, if a partition is computed 02222 with respect to regions, queries about ownership of faces and vertices 02223 are valid. 02224 02225 ------------------------------------------------ 02226 Discussed but unresolved questions: 02227 02228 - We discussed adding functions that give 02229 hints to an implementation about which data mappings the application 02230 will use, allowing the implementation to pre-compute them if it chooses 02231 to. The example discussed was mapping between entities and parts, but 02232 other examples in iMesh may also exist. 02233 02234 - We discussed adding an iterator over entities 02235 with given type/topology in a set or part. We have non-iterator 02236 functionality, but not an iterator. 02237 KDD: Is this true? What is iMesh_initEntIter (and its analogous 02238 KDD: iMeshP_initEntIter)? 02239 02240 - We discussed storing in a partition 02241 information about which "objects" were used in computing the partition. 02242 These objects can be single entities or groups of entities. 02243 KDD: Perhaps this capability should be part of the load-balancing service. 02244 02245 - We discussed designating a given partition as 02246 the "active" partition; i.e., the partition that is actually used in 02247 the distribution of mesh data in distributed memory. We were concerned 02248 that when multiple partitions were used, multiple copies of mesh 02249 entities would be needed to fully support multiple partitions at the 02250 same time. Designating one partition as "active" would store data 02251 with respect to only one partition. 02252 02253 ------------------------------------------------ 02254 Not-yet-discussed, unresolved questions 02255 02256 Entity questions: 02257 - From Carl: "getTag*Operate: Again, we haven't got this in serial. Does 02258 the existence of such operations imply that we expect to implement 02259 fields as tags? (Because that wasn't what I was assuming about field 02260 implementations at all, personally...) Note that I'm not opposed to 02261 this sort of global reduction operation, I just wonder whether it'll see 02262 use outside of field-like situations. If not, then it should be in 02263 parallel fields, not parallel mesh, and usage for 02264 fields-implemented-as-tags should be handled there." 02265 */ 02266 02267 /*--------------------------------*/ 02268 /* NOTES FROM BOOTCAMP MARCH 2008 */ 02269 /*--------------------------------*/ 02270 /* 02271 - Changed getPartRank to getRankOfPart. (Carl) 02272 - Made sure iMeshP_getNumOfTypeAll and iMeshP_getNumOfTopoAll were 02273 documented as collective operations. (Carl) 02274 - Changed suffix "Par" to "All". (Lori) 02275 - Added iMeshP_testPart() to test status of part handle, returning 02276 LOCAL, REMOTE, or INVALID. (Mark M, Lori). 02277 6/25/08: Removed this function since part handles can no longer be remote. 02278 If an application wants to test the validity of a part handle, it can try 02279 to compute its Part ID. 02280 - Changed iMeshP_addCopyOf and iMeshP_rmvCopyOf back to 02281 iMeshP_addGhostOf and iMeshP_rmvGhostOf. If we wanted to use these 02282 functions for adding boundary copies, we'd have to include a list of 02283 already existing remote copies in the arguments, as well as 02284 communicate with parts already owning copies to let them know a ghost 02285 copy has been made. Actually, this raises an interesting question: 02286 does a boundary copy need to know about all ghost copies of it? 02287 - Change getEntParStatus to getEntStatus. (Lori) 02288 - Changed sendEntArrToPartsPar to exchEntArrToPartsAll. (Lori,Tim) 02289 02290 02291 Parts and Processes: 02292 - Martin argued for consecutive unique Part IDs in addition to or 02293 instead of Part handles. He will send use cases. If we decide to 02294 add them back to the interface, we could compute them in 02295 iMeshP_syncPartitionAll rather than in iMeshP_createPart. That is, an 02296 application couldn't access them until after iMeshP_syncPartitionAll. 02297 6/25/08: On follow-up, Martin couldn't recall why having consecutive 02298 PartIDs was necessary. While we all agree they are conceptually nice, 02299 they are difficult to implement and not really necessary. Part IDs will 02300 be globally unique but not necessarily consecutive. 02301 - Are part handles globally unique? They probably need to be 02302 globally unique in order for them to be useful as remote part 02303 handles. Also, does the process rank need to be encoded in the part 02304 handle in order to map from parts to processes for communication? 02305 6/25/08: DECIDED: We will have globally unique part IDs. Part handles 02306 will be valid for only local parts. Accessing remote parts must be done 02307 via Part IDs. 02308 - If in iMeshP_syncPartitionAll, we computed a mapping from part 02309 handles to integers 0,..., k-1, we could store only ranges of 02310 integers to achieve the part-to-process and process-to-parts mappings; 02311 this would require O(P) storage per process for P processes. 02312 6/5/08: DECIDED: Do not need getPartOnRank or getNumPartOnRank. These 02313 functions were troublesome due to their storage or communication requirements. 02314 We decided to remove them. 02315 - Alternatively, the mapping of all parts to processes can be stored 02316 in O(k) total memory, distributed across processors (e.g., a 02317 distributed data directory) but interrogating the directory requires 02318 communication. 02319 6/5/08: See note above. 02320 - iMeshP_getPartsOnRank created discussion and needs to be resolved. 02321 IMeshP_getPartsOnRank would likely require either O(k) storage per 02322 process for k parts or communication. For other points, please see 02323 Mark M's 3/12/08 email. 02324 6/5/08: See note above. 02325 02326 CreateEnt: 02327 - Carl asked if we should have a version of createEnt that accepts a 02328 part handle. Should this function be used only for creating owned 02329 entities? How do you envision creating part boundary entities when a 02330 parallel mesh is initially loaded? 02331 02332 Ghost entities: 02333 - We currently have a mechanism only for pushing ghosts onto other 02334 parts. Will we want a mechanism for pulling them, too? (E.g., a 02335 part says, "I want ghosts for this entity.") 02336 02337 PartNbor functions: 02338 - Did we agree to remove the entity type from these functions? That 02339 is, do we want to return the part IDs for all parts that have 02340 any copies? The entity type was intended to allow us to get the part 02341 IDs for all parts that have copies of a given type (perhaps 02342 ALL_TYPES). 02343 02344 Functions handling both Parts and Entity Sets: 02345 - Tim said these function names (e.g., iMeshP_getNumOfType, 02346 iMeshP_getAllVtxCoord) are too close to existing iMesh function 02347 names, even though the argument lists would be different. He agreed 02348 to email suggestions for better names. 02349 02350 Copies: 02351 - Functions getNumCopies, getCopies, getCopyParts, and getCopyOnPart 02352 have different behavior for ghost and part-boundary copies. Ghosts 02353 will return only itself and its owner in getCopies; part-boundary 02354 entities will return copies on other parts as well. 02355 - Tim envisions applications (e.g., FETI methods) updating tag data 02356 in their copies that they would like to accumulate back to the 02357 owner. Xiaolin said that he writes in his ghosts, but doesn't send 02358 those values back to the owner. Currently, we have the ability 02359 to send tag data only from owners to ghosts. Tim will look at this issue 02360 and propose a solution. 02361 02362 Communication: 02363 - Although we should think in terms of parts, communication really 02364 occurs with respect to processes. We need to make sure all our 02365 communication routines make sense with respect to both processes and 02366 parts, and perhaps, revise their descriptions. Also, if we send to 02367 parts, the implementation really does need the mapping of parts to 02368 processes. 02369 02370 Entity Owner/Status Queries: 02371 - Should we combine functions getEntOwnerPart and getEntStatus into 02372 one function? Or should we combine functions getOwnerCopy and 02373 getEntOwner into one function? Or should we remove getOwnerCopy and 02374 make applications call getOwnerPart followed by getCopyOnPart? 02375 02376 Reducing storage: 02377 - Mark Miller proposed allowing the user to specify the amount of 02378 copying done by the implementation, depending on applications' needs. 02379 For example, for a static viz application, every boundary entity may not 02380 need to know where all its copies are, so the implementation would not 02381 have to store them. Can the implementations accept a flag advising them how 02382 much copying is needed? If so, the implementations could choose to 02383 optimize storage or ignore the flag. 02384 */ 02385 02386 /*-------------------------------------------------------------------- 02387 * SVN File Information 02388 * 02389 * $SVN:Author$ 02390 * $SVN:Date$ 02391 * $SVN:Revision$ 02392 *-------------------------------------------------------------------- 02393 */ 02394 02395 #ifdef __cplusplus 02396 } /* extern "C" */ 02397 #endif 02398 02399 #endif /* !defined(_ITAPS_iMeshP) */
1.7.6.1 
