[MOAB-dev] r2127 - MOAB/trunk/tools/iMesh
kraftche at mcs.anl.gov
kraftche at mcs.anl.gov
Thu Oct 2 15:37:30 CDT 2008
Author: kraftche
Date: 2008-10-02 15:37:30 -0500 (Thu, 02 Oct 2008)
New Revision: 2127
Modified:
MOAB/trunk/tools/iMesh/iMeshP.h
MOAB/trunk/tools/iMesh/iMeshP_protos.h
Log:
o Update iMeshP.h to latest version from RPI repo, with recent
syntax corrections.
o Update iMeshP_protos.h for new iMeshP.h
Modified: MOAB/trunk/tools/iMesh/iMeshP.h
===================================================================
--- MOAB/trunk/tools/iMesh/iMeshP.h 2008-10-02 19:48:09 UTC (rev 2126)
+++ MOAB/trunk/tools/iMesh/iMeshP.h 2008-10-02 20:37:30 UTC (rev 2127)
@@ -1,3 +1,13 @@
+#ifndef iMeshP_H
+#define iMeshP_H
+
+#include "iBase.h"
+#include "iMeshP_protos.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
/*
------------------------------------------------
Background and Terminology:
@@ -64,7 +74,7 @@
Assumptions:
- Each part is wholly contained within a process.
-- A process may have multiple parts.
+- A process may have zero, one or multiple parts.
- Many iMesh functions that accept EntitySet handles
are also useful in the context of part handles.
These functions will be reinterpreted so that they can accept either an
@@ -78,6 +88,11 @@
and remote entity handle of all copies of the entity.
- All parts with copies of any entity know the part ID and
entity handle corresponding to the owner of the entity.
+- Functions that return entity information for a part, set or mesh
+ instance return the information for all entities (including copies and
+ ghosts) in that part, set or mesh instance. Applications can check
+ whether an entity is owned or a ghost using iMeshP_isEntOwner or
+ iMeshP_getEntStatus.
*/
/*------------------------------------------------------------------------*/
@@ -86,49 +101,49 @@
/*------------------------------------------------------------------------*/
/*------------------------------------------------------------------------*/
-// Create a partition handle: Given a mesh instance to contain
-// the partition and a communicator, return a partition
-// handle. May have different creation routines for different
-// communication systems; once created, the application shouldn't have to
-// worry about the communication system again.
-// For serial use, *communicator may be MPI_COMM_SELF or communicator may
-// be NULL.
-// COMMUNICATION: Collective.
+/** Create a partition handle: Given a mesh instance to contain
+ * the partition and a communicator, return a partition
+ * handle. May have different creation routines for different
+ * communication systems; once created, the application shouldn't have to
+ * worry about the communication system again.
+ * For serial use, *communicator may be MPI_COMM_SELF or communicator may
+ * be NULL.
+ * COMMUNICATION: Collective.*/
void iMeshP_createPartitionAll(iMesh_Instance instance,
/*in*/ MPI_Comm *communicator,
/*out*/ iMeshP_PartitionHandle *partition_handle,
int *err);
-// Destroy a partition handle: Given a partition handle, destroy it and
-// invalidate it.
-// COMMUNICATION: Collective.
+/** Destroy a partition handle: Given a partition handle, destroy it and
+ * invalidate it.
+ * COMMUNICATION: Collective.*/
void iMeshP_destroyPartitionAll(iMesh_Instance instance,
/*inout*/ iMeshP_PartitionHandle *partition_handle,
int *err);
-// Given a partition handle, return its communicator.
-// COMMUNICATION: None
+/** Given a partition handle, return its communicator.
+ * COMMUNICATION: None*/
void iMeshP_getPartitionComm(iMesh_Instance instance,
/*in*/ iMeshP_PartitionHandle partition_handle,
/*out*/ MPI_Comm *communicator,
int *err);
-// Update a partition after parts have been added.
-// Gives the implementation an opportunity to locally store info
-// about the partition so that queries on the partition can be
-// performed without synchronous communication.
-// Values that are precomputed by syncPartitionAll:
-// + The total number of parts in a partition.
-// + Mapping between part IDs and processes.
-// + Updated remote entity handle information.
-// COMMUNICATION: Collective.
+/** Update a partition after parts have been added.
+ * Gives the implementation an opportunity to locally store info
+ * about the partition so that queries on the partition can be
+ * performed without synchronous communication.
+ * Values that are precomputed by syncPartitionAll:
+ * + The total number of parts in a partition.
+ * + Mapping between part IDs and processes.
+ * + Updated remote entity handle information.
+ * COMMUNICATION: Collective.*/
void iMeshP_syncPartitionAll(iMesh_Instance instance,
iMeshP_PartitionHandle partition_handle,
int *err);
-// Given a mesh instance, return number of partition handles and
-// all partition handles associated with the mesh instance.
-// COMMUNICATION: None.
+/** Given a mesh instance, return number of partition handles and
+ * all partition handles associated with the mesh instance.
+ * COMMUNICATION: None.*/
void iMeshP_getNumPartitions(iMesh_Instance instance,
/*out*/ int *num_partitions,
int *err);
@@ -139,19 +154,37 @@
/*out*/ int *partition_handle_size,
int *err);
-// Given a partition handle, return the total global number of parts
-// in the partition.
-// COMMUNICATION: None++.
-void iMeshP_getNumParts(iMesh_Instance instance,
+/** Given a partition handle, return the total global number of parts
+ * in the partition.
+ * COMMUNICATION: None++.*/
+void iMeshP_getNumGlobalParts(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
int *num_global_part,
int *err);
-// Map from parts to processes:
-// Given a partition handle and a part ID, return the rank of the
-// process that owns the part.
-// The part may be local or remote.
-// COMMUNICATION: None++.
+/** Given a partition handle, return the number of local (on-process) parts
+ * in the partition.
+ * COMMUNICATION: None++.*/
+void iMeshP_getNumLocalParts(iMesh_Instance instance,
+ const iMeshP_PartitionHandle partition_handle,
+ int *num_local_part,
+ int *err);
+
+/** Given a partition handle, return the number of local parts
+ * in the partition as well as the partition handles for the local parts.
+ * COMMUNICATION: None.*/
+void iMeshP_getLocalParts(iMesh_Instance instance,
+ const iMeshP_PartitionHandle partition_handle,
+ int *num_local_part,
+ iMeshP_PartHandle *part_handles,
+ int part_handles_allocated,
+ int *err);
+
+/** Map from parts to processes:
+ * Given a partition handle and a part ID, return the rank of the
+ * process that owns the part.
+ * The part may be local or remote.
+ * COMMUNICATION: None++.*/
void iMeshP_getRankOfPart(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
/*in*/ const iMeshP_Part part_id,
@@ -165,12 +198,12 @@
/*inout*/ int *rank_allocated,
int *err);
-// Provide global mesh information about a partition.
-// Note that these functions may require communication and, thus,
-// would have to be called by all processes in the partition handle.
-// Given a mesh instance and partition handle, return the
-// total number of entities with given type or topology in the partition.
-// COMMUNICATION: Collective.
+/** Provide global mesh information about a partition.
+ * Note that these functions may require communication and, thus,
+ * would have to be called by all processes in the partition handle.
+ * Given a mesh instance and partition handle, return the
+ * total number of entities with given type or topology in the partition.
+ * COMMUNICATION: Collective.*/
void iMeshP_getNumOfTypeAll(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
const iBase_EntitySetHandle entity_set_handle,
@@ -187,29 +220,29 @@
/*------------------------------------------------------------------------*/
/*------------------------------------------------------------------------*/
-// Given a partition handle, create a part and add it to the
-// partition on the process invoking the creation. Return part handle.
-// COMMUNICATION: None.
+/** Given a partition handle, create a part and add it to the
+ * partition on the process invoking the creation. Return part handle.
+ * COMMUNICATION: None.*/
void iMeshP_createPart(iMesh_Instance instance,
/*in*/ iMeshP_PartitionHandle partition_handle,
/*out*/ iMeshP_PartHandle *part_handle,
int *err);
-// Given a partition handle and a part handle, remove the part
-// from the partition, destroy the part, and invalidate the part handle.
-// If part_handle is remote, an error is returned.
-// COMMUNICATION: None.
+/** Given a partition handle and a part handle, remove the part
+ * from the partition, destroy the part, and invalidate the part handle.
+ * If part_handle is remote, an error is returned.
+ * COMMUNICATION: None.*/
void iMeshP_destroyPart(iMesh_Instance instance,
/*in*/ iMeshP_PartitionHandle partition_handle,
/*inout*/ iMeshP_PartHandle *part_handle,
int *err);
-////////////////////////////////
-// Map between part handles and part IDs.
-// Given a partition handle and a local part handle, return the part ID.
-// If the part handle is not a valid part handle for a local part,
-// return an error.
-// COMMUNICATION: None.
+/********************************
+ * Map between part handles and part IDs.
+ * Given a partition handle and a local part handle, return the part ID.
+ * If the part handle is not a valid part handle for a local part,
+ * return an error.
+ * COMMUNICATION: None.*/
void iMeshP_getPartFromPartHandle(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
@@ -225,9 +258,9 @@
/*inout*/ int *part_ids_allocated,
int *err);
-// Given a partition handle and a part ID, return the part handle
-// if the part is local; otherwise, return error code.
-// COMMUNICATION: None.
+/** Given a partition handle and a part ID, return the part handle
+ * if the part is local; otherwise, return error code.
+ * COMMUNICATION: None.*/
void iMeshP_getPartHandleFromPart(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
@@ -243,29 +276,30 @@
/*inout*/ int *part_handles_allocated,
int *err);
-// Add/remove on-process entities to/from on-process part: Given
-// a partition handle, an entity handle, and a part handle, add/remove the
-// entity to/from the part.
-// On-process add/remove can be accomplished by functions
-// that add/remove entities to/from EntitySets.
-// The part handle is passed in the entity set argument of
-// the appropriate entity set function.
-// The part handle must be local.
-// COMMUNICATION: None.
-// iMeshP_addEntToPart --> iMesh_addEntToSet
-// iMeshP_rmvEntFromPart --> iMesh_rmvEntFromSet
-// iMeshP_addEntArrToPart --> iMesh_addEntArrToSet
-// iMeshP_rmvEntArrFromPart --> iMesh_rmvEntArrFromSet
+/** Add/remove on-process entities to/from on-process part: Given
+ * a partition handle, an entity handle, and a part handle, add/remove the
+ * entity to/from the part.
+ * On-process add/remove can be accomplished by functions
+ * that add/remove entities to/from EntitySets.
+ * The part handle is passed in the entity set argument of
+ * the appropriate entity set function.
+ * The part handle must be local.
+ * COMMUNICATION: None.
+ * iMeshP_addEntToPart --> iMesh_addEntToSet
+ * iMeshP_rmvEntFromPart --> iMesh_rmvEntFromSet
+ * iMeshP_addEntArrToPart --> iMesh_addEntArrToSet
+ * iMeshP_rmvEntArrFromPart --> iMesh_rmvEntArrFromSet
+ */
-// Identify parts that neighbor a given part.
-// Given a partition handle, a part handle, and an entity type,
-// return the number of parts in the partition that neighbor the given part
-// (i.e., that (1) have copies of entities of the given entity type owned by
-// the given part or (2) own entities of the given entity type that are
-// copied on the given part).
-// If the part_handle is invalid, an error is returned.
-// COMMUNICATION: None++.
+/** Identify parts that neighbor a given part.
+ * Given a partition handle, a part handle, and an entity type,
+ * return the number of parts in the partition that neighbor the given part
+ * (i.e., that (1) have copies of entities of the given entity type owned by
+ * the given part or (2) own entities of the given entity type that are
+ * copied on the given part).
+ * If the part_handle is invalid, an error is returned.
+ * COMMUNICATION: None++.*/
void iMeshP_getNumPartNbors(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
/*in*/ const iMeshP_PartHandle part_handle,
@@ -281,14 +315,14 @@
/*inout*/ int *num_part_nbors_allocated,
int *err);
-// Given a partition handle, a part handle, and an entity type,
-// return the number of neighbor part IDs and the part IDs of
-// all parts in the partition that neighbor the given part
-// (i.e., that (1) have copies of entities of the given entity type owned by
-// the given part or (2) own entities of the given entity type that are
-// copied on the given part).
-// If part_handle is invalid, an error is returned.
-// COMMUNICATION: None++.
+/** Given a partition handle, a part handle, and an entity type,
+ * return the number of neighbor part IDs and the part IDs of
+ * all parts in the partition that neighbor the given part
+ * (i.e., that (1) have copies of entities of the given entity type owned by
+ * the given part or (2) own entities of the given entity type that are
+ * copied on the given part).
+ * If part_handle is invalid, an error is returned.
+ * COMMUNICATION: None++.*/
void iMeshP_getPartNbors(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
/*in*/ const iMeshP_PartHandle part_handle,
@@ -310,16 +344,17 @@
/*out*/ int *nbor_part_ids_size,
int *err);
-// Provide part boundary info:
-// Note: Allow optional specification of desired entity types and
-// topologies; allow target part handle = iMeshP_ALL_PARTS to
-// count/include all qualifying boundary entities of part.
-// Given a partition handle, a part handle, entity type and topology, and a
-// target part ID, return the number of qualifying entities on
-// the part boundary shared with the target part.
-// If part_handle is invalid, an error is returned.
-// COMMUNICATION: None.
+/** Provide part boundary info:
+ * Note: Allow optional specification of desired entity types and
+ * topologies; allow target part handle = iMeshP_ALL_PARTS to
+ * count/include all qualifying boundary entities of part.
+ * Given a partition handle, a part handle, entity type and topology, and a
+ * target part ID, return the number of qualifying entities on
+ * the part boundary shared with the target part.
+ * If part_handle is invalid, an error is returned.
+ * COMMUNICATION: None.*/
void iMeshP_getNumPartBdryEnts(iMesh_Instance instance,
+ /*in*/ const iMeshP_PartitionHandle partition_handle,
/*in*/ const iMeshP_PartHandle part_handle,
/*in*/ const int entity_type,
/*in*/ const int entity_topology,
@@ -327,13 +362,14 @@
/*out*/ int *num_entities,
int *err);
-// Given a partition handle, a part handle, entity type and topology, and a
-// target part ID, return an array of entity handles for all
-// qualifying entities along the part boundary shared with the target
-// part.
-// If part_handle is invalid, an error is returned.
-// COMMUNICATION: None.
+/** Given a partition handle, a part handle, entity type and topology, and a
+ * target part ID, return an array of entity handles for all
+ * qualifying entities along the part boundary shared with the target
+ * part.
+ * If part_handle is invalid, an error is returned.
+ * COMMUNICATION: None.*/
void iMeshP_getPartBdryEnts(iMesh_Instance instance,
+ /*in*/ const iMeshP_PartitionHandle partition_handle,
/*in*/ const iMeshP_PartHandle part_handle,
/*in*/ const int entity_type,
/*in*/ const int entity_topology,
@@ -343,14 +379,15 @@
/*out*/ int *entity_handles_size,
int *err);
-// Boundary iterators: Given a partition handle, a part handle, and a
-// target part ID, return an iterator over all entities along
-// the part boundary shared with the target part.
-// Functionality for getNext, reset, and end is
-// provided through the regular iMesh iterator functions.
-// If part_handle is invalid, an error is returned.
-// COMMUNICATION: None.
+/** Boundary iterators: Given a partition handle, a part handle, and a
+ * target part ID, return an iterator over all entities along
+ * the part boundary shared with the target part.
+ * Functionality for getNext, reset, and end is
+ * provided through the regular iMesh iterator functions.
+ * If part_handle is invalid, an error is returned.
+ * COMMUNICATION: None.*/
void iMeshP_initPartBdryEntIter(iMesh_Instance instance,
+ /*in*/ const iMeshP_PartitionHandle partition_handle,
/*in*/ const iMeshP_PartHandle part_handle,
/*in*/ const int entity_type,
/*in*/ const int entity_topology,
@@ -358,6 +395,7 @@
/*inout*/ iMesh_EntityIterator* entity_iterator,
int* err);
void iMeshP_initPartBdryEntArrIter(iMesh_Instance instance,
+ /*in*/ const iMeshP_PartitionHandle partition_handle,
/*in*/ const iMeshP_PartHandle part_handle,
/*in*/ const int entity_type,
/*in*/ const int entity_topology,
@@ -367,28 +405,35 @@
int* err);
-// Provide entity information about a part and entity set.
-// Given an entity set handle
-// and a part handle, return the number of entities of given type/topo
-// that are in both the part and the entity set.
-// If part_handle is invalid, an error is returned.
-// COMMUNICATION: None.
+/** Provide entity information about a part and entity set.
+ * Given an entity set handle
+ * and a part handle, return the number of entities of given type/topo
+ * that are in both the part and the entity set.
+ * If part_handle is invalid, an error is returned.
+ * COMMUNICATION: None.*/
void iMeshP_getNumOfType(iMesh_Instance instance,
+ const iMeshP_PartitionHandle partition_handle,
const iMeshP_PartHandle part_handle,
const iBase_EntitySetHandle entity_set_handle,
- const int entity_type, int *num_type, int *err);
+ const int entity_type,
+ int *num_type,
+ int *err);
void iMeshP_getNumOfTopo(iMesh_Instance instance,
+ const iMeshP_PartitionHandle partition_handle,
const iMeshP_PartHandle part_handle,
const iBase_EntitySetHandle entity_set_handle,
- const int entity_topology, int *num_topo, int *err);
+ const int entity_topology,
+ int *num_topo,
+ int *err);
-// Given an entity set handle
-// and a part handle, return vertex information for vertices
-// that are in both the part and the entity set.
-// If part_handle is invalid, an error is returned.
-// COMMUNICATION: None.
+/** Given an entity set handle
+ * and a part handle, return vertex information for vertices
+ * that are in both the part and the entity set.
+ * If part_handle is invalid, an error is returned.
+ * COMMUNICATION: None.*/
void iMeshP_getAllVtxCoords(iMesh_Instance instance,
- iMeshP_PartHandle part_handle,
+ const iMeshP_PartitionHandle partition_handle,
+ const iMeshP_PartHandle part_handle,
const iBase_EntitySetHandle entity_set_handle,
double** coordinates,
int* coordinates_allocated,
@@ -396,9 +441,11 @@
int** in_entity_set,
int* in_entity_set_allocated,
int* in_entity_set_size,
- int* storage_order, int *err);
+ int* storage_order,
+ int *err);
void iMeshP_getVtxCoordIndex(iMesh_Instance instance,
- iMeshP_PartHandle part_handle,
+ const iMeshP_PartitionHandle partition_handle,
+ const iMeshP_PartHandle part_handle,
const iBase_EntitySetHandle entity_set_handle,
const int requested_entity_type,
const int requested_entity_topology,
@@ -414,13 +461,14 @@
int* entity_topologies_size,
int *err);
-// Given an entity set handle
-// and a part handle, return entity handles for entities
-// that are in both the part and the entity set.
-// If part_handle is invalid, an error is returned.
-// COMMUNICATION: None.
+/** Given an entity set handle
+ * and a part handle, return entity handles for entities
+ * that are in both the part and the entity set.
+ * If part_handle is invalid, an error is returned.
+ * COMMUNICATION: None.*/
void iMeshP_getEntities(iMesh_Instance instance,
- iMeshP_PartHandle part_handle,
+ const iMeshP_PartitionHandle partition_handle,
+ const iMeshP_PartHandle part_handle,
const iBase_EntitySetHandle entity_set_handle,
const int entity_type,
const int entity_topology,
@@ -429,13 +477,14 @@
int* entity_handles_size,
int *err);
-// Given an entity set handle
-// and a part handle, return entity adjacencies for entities
-// that are in both the part and the entity set.
-// If part_handle is invalid, an error is returned.
-// COMMUNICATION: None.
+/** Given an entity set handle
+ * and a part handle, return entity adjacencies for entities
+ * that are in both the part and the entity set.
+ * If part_handle is invalid, an error is returned.
+ * COMMUNICATION: None.*/
void iMeshP_getAdjEntities(iMesh_Instance instance,
- iMeshP_PartHandle part_handle,
+ const iMeshP_PartitionHandle partition_handle,
+ const iMeshP_PartHandle part_handle,
const iBase_EntityHandle entity_set_handle,
const int entity_type_requestor,
const int entity_topology_requestor,
@@ -451,21 +500,23 @@
int* in_entity_set_size,
int *err);
-// Provide entity and array iterators for entities within both a given part
-// and a given entity set.
-// Functionality for getNext, reset, and end is
-// provided through the regular iMesh iterator functions.
-// If part_handle is invalid, an error is returned.
-// COMMUNICATION: None.
+/** Provide entity and array iterators for entities within both a given part
+ * and a given entity set.
+ * Functionality for getNext, reset, and end is
+ * provided through the regular iMesh iterator functions.
+ * If part_handle is invalid, an error is returned.
+ * COMMUNICATION: None.*/
void iMeshP_initEntIter(iMesh_Instance instance,
- iMeshP_PartHandle part_handle,
+ const iMeshP_PartitionHandle partition_handle,
+ const iMeshP_PartHandle part_handle,
const iBase_EntitySetHandle entity_set_handle,
const int requested_entity_type,
const int requested_entity_topology,
iMesh_EntityIterator* entity_iterator,
int *err);
void iMeshP_initEntArrIter(iMesh_Instance instance,
- iMeshP_PartHandle part_handle,
+ const iMeshP_PartitionHandle partition_handle,
+ const iMeshP_PartHandle part_handle,
const iBase_EntitySetHandle entity_set_handle,
const int requested_entity_type,
const int requested_entity_topology,
@@ -479,34 +530,36 @@
/*------------------------------------------------------------------------*/
/*------------------------------------------------------------------------*/
-// Provide part information about an entity: Given an entity and a
-// partition handle, return the part ID of the part that owns the entity.
-// Return an error code if an entity is not in the partition.
-// COMMUNICATION: None++.
+/** Provide part information about an entity: Given an entity and a
+ * partition handle, return the part ID of the part that owns the entity.
+ * Return an error code if an entity is not in the partition.
+ * COMMUNICATION: None++.*/
void iMeshP_getEntOwnerPart(iMesh_Instance instance,
/*in*/ const iMeshP_PartitionHandle partition_handle,
- /*in*/ iBase_EntityHandle entity_handle,
+ /*in*/ const iBase_EntityHandle entity_handle,
/*out*/ iMeshP_Part *part_id,
int* err);
void iMeshP_getEntOwnerPartArr(iMesh_Instance instance,
/*in*/ const iMeshP_PartitionHandle partition_handle,
- /*in*/ iBase_EntityHandle *entity_handles,
- /*in*/ int entity_handles_size,
+ /*in*/ const iBase_EntityHandle *entity_handles,
+ /*in*/ const int entity_handles_size,
/*inout*/ iMeshP_Part **part_ids,
/*inout*/ int *part_ids_allocated,
int* err);
-// Provide entity categorization within part.
-// Given a partition handle, a part handle, and an entity handle, return a
-// flag indicating whether the entity is owned by the part.
-// If part_handle is invalid, an error is returned.
-// COMMUNICATION: None.
+/** Provide entity categorization within part.
+ * Given a partition handle, a part handle, and an entity handle, return a
+ * flag indicating whether the entity is owned by the part.
+ * If part_handle is invalid, an error is returned.
+ * COMMUNICATION: None.*/
void iMeshP_isEntOwner(iMesh_Instance instance,
+ /*in*/ const iMeshP_PartitionHandle partition_handle,
/*in*/ const iMeshP_PartHandle part_handle,
/*in*/ const iBase_EntityHandle entity_handle,
/*out*/ int* is_owner,
int *err);
void iMeshP_isEntOwnerArr(iMesh_Instance instance,
+ /*in*/ const iMeshP_PartitionHandle partition_handle,
/*in*/ const iMeshP_PartHandle part_handle,
/*in*/ const iBase_EntityHandle *entity_handles,
/*in*/ const int entity_handles_size,
@@ -514,17 +567,19 @@
/*inout*/ int* is_owner_allocated,
int *err);
-// Given a partition handle, a part handle, and an entity handle, return a
-// flag indicating whether the entity is strictly internal, on a
-// boundary, or a ghost.
-// If part_handle is invalid, an error is returned.
-// COMMUNICATION: None.
+/** Given a partition handle, a part handle, and an entity handle, return a
+ * flag indicating whether the entity is strictly internal, on a
+ * boundary, or a ghost.
+ * If part_handle is invalid, an error is returned.
+ * COMMUNICATION: None.*/
void iMeshP_getEntStatus(iMesh_Instance instance,
+ /*in*/ const iMeshP_PartitionHandle partition_handle,
/*in*/ const iMeshP_PartHandle part_handle,
/*in*/ const iBase_EntityHandle entity_handle,
/*out*/ int* par_status, // Values=INTERNAL,BOUNDARY,GHOST
int *err);
void iMeshP_getEntStatusArr(iMesh_Instance instance,
+ /*in*/ const iMeshP_PartitionHandle partition_handle,
/*in*/ const iMeshP_PartHandle part_handle,
/*in*/ const iBase_EntityHandle *entity_handles,
/*in*/ const int entity_handles_size,
@@ -532,22 +587,22 @@
/*inout*/ int* par_status_allocated,
int *err);
-// Provide information about copies of entities.
-// All these functions should work on the local process as well as
-// remote processes; entity handles returned are likely but not
-// necessarily remote.
-// Given a partition handle and an entity handle, return the number
-// of copies of the entity in the partition.
-// COMMUNICATION: None++.
+/** Provide information about copies of entities.
+ * All these functions should work on the local process as well as
+ * remote processes; entity handles returned are likely but not
+ * necessarily remote.
+ * Given a partition handle and an entity handle, return the number
+ * of copies of the entity in the partition.
+ * COMMUNICATION: None++.*/
void iMeshP_getNumCopies(iMesh_Instance instance,
/*in*/ const iMeshP_PartitionHandle partition_handle,
/*in*/ const iBase_EntityHandle entity_handle,
/*out*/ int *num_copies_ent,
int *err);
-// Given a partition handle and an entity handle, return the part IDs
-// of copies of the entity in the partition. (Requested by Onkar.)
-// COMMUNICATION: None++.
+/** Given a partition handle and an entity handle, return the part IDs
+ * of copies of the entity in the partition. (Requested by Onkar.)
+ * COMMUNICATION: None++.*/
void iMeshP_getCopyParts(iMesh_Instance instance,
/*in*/ const iMeshP_PartitionHandle partition_handle,
/*in*/ const iBase_EntityHandle entity_handle,
@@ -556,9 +611,9 @@
/*out*/ int *part_ids_size,
int *err);
-// Given a partition handle and an entity handle, return (remote) entity
-// handles and part IDs of all copies of the entity.
-// COMMUNICATION: None++.
+/** Given a partition handle and an entity handle, return (remote) entity
+ * handles and part IDs of all copies of the entity.
+ * COMMUNICATION: None++.*/
void iMeshP_getCopies(iMesh_Instance instance,
/*in*/ const iMeshP_PartitionHandle partition_handle,
/*in*/ const iBase_EntityHandle entity_handle,
@@ -569,22 +624,22 @@
/*inout*/ int *copies_entity_handles_allocated,
int *err);
-// Given a partition handle, an entity handle and a part ID, return the
-// (possibly remote) entity handle of the entity in the specified part.
-// Return an error if the entity does not exist in the specified part.
-// COMMUNICATION: None++.
+/** Given a partition handle, an entity handle and a part ID, return the
+ * (possibly remote) entity handle of the entity in the specified part.
+ * Return an error if the entity does not exist in the specified part.
+ * COMMUNICATION: None++.*/
void iMeshP_getCopyOnPart(iMesh_Instance instance,
/*in*/ const iMeshP_PartitionHandle partition_handle,
/*in*/ const iBase_EntityHandle entity_handle,
- /*in*/ iMeshP_Part* part_id,
+ /*in*/ const iMeshP_Part* part_id,
/*out*/ iBase_EntityHandle* copy_entity_handle,
int *err);
-// Given a partition handle and an entity handle, return the entity
-// handle and part ID from the owner of the entity (e.g., the
-// entity handle of the copy that has right-to-modify).
-// COMMUNICATION: None++.
+/** Given a partition handle and an entity handle, return the entity
+ * handle and part ID from the owner of the entity (e.g., the
+ * entity handle of the copy that has right-to-modify).
+ * COMMUNICATION: None++.*/
void iMeshP_getOwnerCopy(iMesh_Instance instance,
/*in*/ const iMeshP_PartitionHandle partition_handle,
/*in*/ const iBase_EntityHandle entity_handle,
@@ -595,10 +650,10 @@
/*************************************************
******* COMMUNICATION **********
*************************************************/
-////////////////////////////////
-// Non-blocking calls for off-processor mesh-modification return a request
-// that indicates whether or not the operation has completed.
-// The following functions receive and process requests.
+/***********************************
+ * Non-blocking calls for off-processor mesh-modification return a request
+ * that indicates whether or not the operation has completed.
+ * The following functions receive and process requests.*/
/**\brief Wait for specified request to complete
*
@@ -606,9 +661,9 @@
* \param req Request object to wait on
* \param stat Status of communication request
* \param err Error returned from function
+ * COMMUNICATION: Blocking point-to-point.
*/
-// COMMUNICATION: Blocking point-to-point.
-iMeshP_Wait(iMesh_Instance instance,
+void iMeshP_Wait(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
/*in*/ iMeshP_RequestHandle req,
/*out*/ iMeshP_Status stat,
@@ -622,8 +677,8 @@
* \param index Index of request in req which was completed
* \param stat Status of communication request
* \param err Error returned from function
+ * COMMUNICATION: Blocking point-to-point.
*/
-// COMMUNICATION: Blocking point-to-point.
void iMeshP_WaitAny(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
/*in*/ iMeshP_RequestHandle *req,
@@ -639,8 +694,8 @@
* \param req_size Number of request objects
* \param stat Status of communication request
* \param err Error returned from function
+ * COMMUNICATION: Blocking point-to-point.
*/
-// COMMUNICATION: Blocking point-to-point.
void iMeshP_WaitAll(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
/*in*/ iMeshP_RequestHandle *req,
@@ -658,8 +713,8 @@
* \param entities_alloc Allocated size of entities vector
* \param entities_size Occupied size of entities vector
* \param err Error returned from function
+ * COMMUNICATION: Blocking point-to-point.
*/
-// COMMUNICATION: Blocking point-to-point.
void iMeshP_WaitEnt(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
/*in*/ iMeshP_RequestHandle req,
@@ -675,8 +730,8 @@
* \param flag Returned true if request completed
* \param stat Status of communication request
* \param err Error returned from function
+ * COMMUNICATION: Point-to-point; non-blocking.
*/
-// COMMUNICATION: Point-to-point; non-blocking.
void iMeshP_Test(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
/*in*/ iMeshP_RequestHandle req,
@@ -684,25 +739,26 @@
/*out*/ iMeshP_Status *stat,
/*out*/ int *err)
-// Poll for requests. The internals of this function are going to have
-// to cover a lot of ground. The array in the return is there as a
-// placeholder to tell the application that something interesting / useful
-// has been done to a handle. This might indicate successful in-migration,
-// a recent change in vertex location, or successful completion of handle
-// matching.
-//
-// Returns an array of requests that have been handled. If
-// the array has a size allocated already, then the implementation stops
-// working when it has generated that many completed requests, even if there
-// are more messages waiting. The syntax on this call should perhaps be
-// modified somewhat to make it more compatible with an analogous MPI call.
-//
-// Should also perhaps have its name changed to handleMessages or some such
-// thing, since the function should not only poll for unexpected
-// messages, but also handle expected ones; these is no reason to
-// separately call two different functions to handle non-blocking receives
-// for different types of messages.
-// COMMUNICATION: non-blocking; point-to-point.
+/** Poll for requests. The internals of this function are going to have
+ * to cover a lot of ground. The array in the return is there as a
+ * placeholder to tell the application that something interesting / useful
+ * has been done to a handle. This might indicate successful in-migration,
+ * a recent change in vertex location, or successful completion of handle
+ * matching.
+ *
+ * Returns an array of requests that have been handled. If
+ * the array has a size allocated already, then the implementation stops
+ * working when it has generated that many completed requests, even if there
+ * are more messages waiting. The syntax on this call should perhaps be
+ * modified somewhat to make it more compatible with an analogous MPI call.
+ *
+ * Should also perhaps have its name changed to handleMessages or some such
+ * thing, since the function should not only poll for unexpected
+ * messages, but also handle expected ones; these is no reason to
+ * separately call two different functions to handle non-blocking receives
+ * for different types of messages.
+ * COMMUNICATION: non-blocking; point-to-point.
+ */
void iMeshP_pollForRequests(iMesh_Instance instance,
iMeshP_PartitionHandle partition_handle,
iMeshP_RequestHandle **requests_completed,
@@ -714,14 +770,14 @@
******* Requests for off-processor mesh modification ******
********************************************************************/
-////////////////////////////////
-// Add entities to on-process and/or off-process parts:
-// Collective-communication version:
-// iMeshP_exchEntArrToPartsPar is a collective, non-blocking operation
-// to be called by all processes in the partition's communicator.
-// An iMeshP_RequestHandle is returned; any of the iMeshP_Wait functions can be
-// used to block until the request is completed.
-// COMMUNICATION: Collective. Non-blocking.
+/*********************************
+ * Add entities to on-process and/or off-process parts:
+ * Collective-communication version:
+ * iMeshP_exchEntArrToPartsPar is a collective, non-blocking operation
+ * to be called by all processes in the partition's communicator.
+ * An iMeshP_RequestHandle is returned; any of the iMeshP_Wait functions can be
+ * used to block until the request is completed.
+ * COMMUNICATION: Collective. Non-blocking.*/
void iMeshP_exchEntArrToPartsAll(iMesh_Instance instance,
/*in*/ const iMeshP_PartitionHandle partition_handle,
/*in*/ const iBase_EntityHandle *entity_handles,
@@ -732,20 +788,20 @@
/*out*/ iMeshP_RequestHandle *request,
int *err);
-////////////////////////////////////////////////////////////////////////////
+/************************************************************************/
-// Request in-migration to a given part of an entity and its upward adjacencies.
-// This is a pull migration. The
-// entity must be on the part bdry and is identified by local handle, and
-// the implementation handles the rest. This operation will require multiple
-// rounds of communication, and at some times certain entities may be
-// locked (unavailable for local modification) while info about their
-// remote copies is still in question.
-// It's worth mentioning that implementations will have to take care to
-// migrate tags and parallel set membership as well as adjacency info.
-// CHANGES: Returns a request handle. Assumes you wouldn't be asking if
-// you didn't need the upward adjacencies as well.
-// COMMUNICATION: point-to-point, non-blocking, pull.
+/** Request in-migration to a given part of an entity and its upward adjacencies.
+ * This is a pull migration. The
+ * entity must be on the part bdry and is identified by local handle, and
+ * the implementation handles the rest. This operation will require multiple
+ * rounds of communication, and at some times certain entities may be
+ * locked (unavailable for local modification) while info about their
+ * remote copies is still in question.
+ * It's worth mentioning that implementations will have to take care to
+ * migrate tags and parallel set membership as well as adjacency info.
+ * CHANGES: Returns a request handle. Assumes you wouldn't be asking if
+ * you didn't need the upward adjacencies as well.
+ * COMMUNICATION: point-to-point, non-blocking, pull. */
void iMeshP_migrateEntity(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
const iMeshP_PartHandle part_handle,
@@ -753,27 +809,27 @@
iMeshP_RequestHandle *request,
int *err);
-// Update vertex coordinates. One could argue that we could overload
-// the setVtxCoords function to do this, and maybe we should. But that
-// obfuscates when communication could occur. The communication here is
-// push-and-forget.
-// Because this is push-and-forget, no request handle -should- be generated.
-// COMMUNICATION: point-to-point, non-blocking, push-and-forget.
+/** Update vertex coordinates. One could argue that we could overload
+ * the setVtxCoords function to do this, and maybe we should. But that
+ * obfuscates when communication could occur. The communication here is
+ * push-and-forget.
+ * Because this is push-and-forget, no request handle -should- be generated.
+ * COMMUNICATION: point-to-point, non-blocking, push-and-forget.*/
void iMeshP_updateVtxCoords(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
const iBase_EntityHandle local_vertex_handle,
int *err);
-// Replace entities. This refers to changes on the part bdry where the
-// application/service is responsible for ensuring that things are done
-// identically on both sides and that the args are passed in an order that
-// can be matched. (Specifically, matching new entities should appear in
-// the same order in the call array.) Communication here could be a
-// two-way push-and-forget, or some variant on push-and-confirm.
-// CHANGES: At Onkar's suggestion, added an offset array (similar to array
-// adjacency requests) so that a single call can easily handle coordination
-// with multiple entities on part-boundary.
-// COMMUNICATION: point-to-point, non-blocking, push-and-forget.
+/** Replace entities. This refers to changes on the part bdry where the
+ * application/service is responsible for ensuring that things are done
+ * identically on both sides and that the args are passed in an order that
+ * can be matched. (Specifically, matching new entities should appear in
+ * the same order in the call array.) Communication here could be a
+ * two-way push-and-forget, or some variant on push-and-confirm.
+ * CHANGES: At Onkar's suggestion, added an offset array (similar to array
+ * adjacency requests) so that a single call can easily handle coordination
+ * with multiple entities on part-boundary.
+ * COMMUNICATION: point-to-point, non-blocking, push-and-forget. */
void iMeshP_replaceOnPartBdry(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
const iBase_EntityHandle *old_entities,
@@ -785,18 +841,18 @@
int *err);
-// The ability to create and delete copies is likely
-// to be useful, even though for common topologically-based cases, copies
-// maintainance can (and IMO should) be done automagically, either at
-// migration time or during iMeshP_syncMeshAll.
-// Communication here is
-// push-and-confirm for creation (so that the original knows ID's of the
-// ghosts), push-and-forget for deletion (in the latter case, no request
-// handle is needed). I'm assuming here that the closure of a new ghost
-// will be pushed automatically as part of the underlying communication,
-// and that the remote part will clean up the closure as appropriate during
-// deletion.
-// COMMUNICATION: point-to-point, non-blocking, push.
+/** The ability to create and delete copies is likely
+ * to be useful, even though for common topologically-based cases, copies
+ * maintainance can (and IMO should) be done automagically, either at
+ * migration time or during iMeshP_syncMeshAll.
+ * Communication here is
+ * push-and-confirm for creation (so that the original knows ID's of the
+ * ghosts), push-and-forget for deletion (in the latter case, no request
+ * handle is needed). I'm assuming here that the closure of a new ghost
+ * will be pushed automatically as part of the underlying communication,
+ * and that the remote part will clean up the closure as appropriate during
+ * deletion.
+ * COMMUNICATION: point-to-point, non-blocking, push.*/
void iMeshP_addGhostOf(iMesh_Instance instance,
/* in */ const iMeshP_PartitionHandle partition_handle,
/* in */ const iMeshP_Part target_part_id,
@@ -810,22 +866,25 @@
/* in */ const iBase_EntityHandle copy_to_purge,
int *err);
-// Done with mesh modification. This is a blocking call, to get
-// everything up-to-date and back in synch. Essentially, waits for all
-// message traffic to clear, as well as (possibly) rebuilding a bunch of
-// ghost info that was allowed to go obsolete.
+/** Done with mesh modification. This is a blocking call, to get
+ * everything up-to-date and back in synch. Essentially, waits for all
+ * message traffic to clear, as well as (possibly) rebuilding a bunch of
+ * ghost info that was allowed to go obsolete.*/
void iMeshP_syncMeshAll(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
int *err);
-////////////////////////////////////////////////////////////////////////////
-// Functions to exchange Tag data.
+/****************************************************************************/
+/* Functions to send Tag data from owning entities to copies.*/
-/**\brief Synchronously exchange tag data for entity type/topo
+/**\brief Synchronously send tag data for entity type/topo
* and part
*
- * Exchange tag information for shared entities of specified type/
- * topology to specified part. This version operates on all
+ * Send tag information for shared entities of specified type/
+ * topology to specified part.
+ * The tag data is "pushed" from the
+ * owner entities to all copies.
+ * This version operates on all
* shared entities of specified type/topology (or all
* types/topologies if iMesh_ALL_TYPE or iMesh_ALL_TOPOLOGIES are
* given). This function assumes tag handles given on various
@@ -835,44 +894,46 @@
* \param tag Tag handle to exchange
* \param entity_type Tag data exchanged only for this entity type
* \param entity_topo Tag data exchanged only for this entity topology
- * \param with_part Tag info exchanged only with this part
* \param err Error returned from function
*/
-void iMeshP_ExchTags(iMesh_Instance instance,
+void iMeshP_pushTags(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
/*in*/ iBase_TagHandle tag,
/*in*/ int entity_type,
/*in*/ int entity_topo,
- /*in*/ iMeshP_Part with_part_id,
/*out*/ int *err)
-/**\brief Synchronously exchange tag data for entities and part
+/**\brief Synchronously send tag data for entities and part
*
- * Exchange tag information for specified entities, which must
- * already be shared. This function assumes tag handles given on various
+ * Send tag information for specified entities, which must
+ * already be shared.
+ * The tag data is "pushed" from the
+ * owner entities to all copies.
+ * This function assumes tag handles given on various
* calling parts are consistent, i.e. they have the same name,
* data type, size, etc. This call blocks until communication is
* completed
* \param tag Tag handle to exchange
* \param entities Entities for which to exchange data
* \param entities_size Number of entities
- * \param with_part Tag info exchanged only with this part
* \param err Error returned from function
*/
-void iMeshP_ExchTagsEnt(iMesh_Instance instance,
+void iMeshP_pushTagsEnt(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
/*in*/ iBase_TagHandle tag,
/*in*/ iBase_EntityHandle *entities,
/*in*/ int entities_size,
- /*in*/ iMeshP_Part with_part_id,
/*out*/ int *err)
-/**\brief Asynchronously exchange tag data for entity type/topo
+/**\brief Asynchronously send tag data for entity type/topo
* and part
*
- * Exchange tag information for shared entities of specified type/
- * topology to specified part. This version operates on all
+ * Send tag information for shared entities of specified type/
+ * topology to specified part.
+ * The tag data is "pushed" from the
+ * owner entities to all copies.
+ * This version operates on all
* shared entities of specified type/topology (or all
* types/topologies if iMesh_ALL_TYPE or iMesh_ALL_TOPOLOGIES are
* given). This function assumes tag handles given on various
@@ -882,45 +943,43 @@
* \param tag Tag handle to exchange
* \param entity_type Tag data exchanged only for this entity type
* \param entity_topo Tag data exchanged only for this entity topology
- * \param with_part Tag info exchanged only with this part
* \param iMeshP_RequestHandle Request object used in call to
* iMeshP_Wait or iMeshP_WaitEnt
* \param err Error returned from function
*/
-void iMeshP_IExchTags(iMesh_Instance instance,
+void iMeshP_iPushTags(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
/*in*/ iBase_TagHandle tag,
/*in*/ int entity_type,
/*in*/ int entity_topo,
- /*in*/ iMeshP_Part with_part_id,
/*out*/ iMeshP_RequestHandle *req,
/*out*/ int *err)
-/**\brief Asynchronously exchange tag data for entities and part
+/**\brief Asynchronously send tag data for entities and part
*
- * Exchange tag information for specified entities, which must
- * already be shared. This function assumes tag handles given on various
+ * Sedn tag information for specified entities, which must
+ * already be shared.
+ * The tag data is "pushed" from the
+ * owner entities to all copies.
+ * This function assumes tag handles given on various
* calling parts are consistent, i.e. they have the same name,
* data type, size, etc. Applications can call iMeshP_Wait or
* iMeshP_WaitEnt to block until associated call completes
* \param tag Tag handle to exchange
* \param entities Entities for which to exchange data
* \param entities_size Number of entities
- * \param with_part Tag info exchanged only with this part
* \param iMeshP_RequestHandle Request object used in call to
* iMeshP_Wait or iMeshP_WaitEnt
* \param err Error returned from function
*/
-void iMeshP_IExchTagsEnt(iMesh_Instance instance,
+void iMeshP_iPushTagsEnt(iMesh_Instance instance,
const iMeshP_PartitionHandle partition_handle,
/*in*/ iBase_TagHandle tag,
/*in*/ iBase_EntityHandle *entities,
/*in*/ int entities_size,
- /*in*/ iMeshP_Part with_part_id,
/*out*/ iMeshP_RequestHandle *req,
/*out*/ int *err)
-
/* GHOST ENTITY SUPPORT */
/*
The triplet describing a ghosting "rule" (ghost dim, bridge dim, #
@@ -953,13 +1012,16 @@
* \param bridge_dim Dimension through which bridge adjacencies are found
* \param num_layers Number of layers of ghost entities
* \param err Error returned from function
+ * \param include_copies Create ghosts of non-owned part boundary entities?
+ * (1/0)
* COMMUNICATION: Collective. Blocking.
*/
-iMeshP_createGhostEnts(/*in*/ iMesh_Instance instance,
+void iMeshP_createGhostEnts(/*in*/ iMesh_Instance instance,
/*in*/ iMeshP_PartitionHandle partition_handle,
/*in*/ int ghost_dim,
/*in*/ int bridge_dim,
/*in*/ int num_layers,
+ /*in*/ int include_copies,
/*out*/ int *err);
/* \brief Delete all ghost entities between parts/processors.
@@ -968,7 +1030,7 @@
* \param err Error returned from function
* COMMUNICATION: None.
*/
-iMeshP_deleteGhostEnts(/*in*/ iMesh_Instance instance,
+void iMeshP_deleteGhostEnts(/*in*/ iMesh_Instance instance,
/*in*/ iMeshP_PartitionHandle partition_handle,
/*out*/ int *err);
@@ -982,7 +1044,7 @@
* \param err Error returned from function
* COMMUNICATION: None.
*/
-iMeshP_ghostEntInfo(/*in*/ iMesh_Instance instance,
+void iMeshP_ghostEntInfo(/*in*/ iMesh_Instance instance,
/*in*/ iMeshP_PartitionHandle partition_handle,
/*out*/ int num_ghost_rules,
/*inout*/ int *ghost_rules_allocated,
@@ -992,6 +1054,53 @@
/*out*/ int **num_layers,
/*out*/ int *err);
+/********************************************************************
+ ******* FILE I/O ******
+ ********************************************************************/
+/* \brief iMeshP file I/O closely aligns with iMesh file I/O. The major
+ * change is the addition of a iMeshP_PartitionHandle argument to both
+ * iMeshP_load and iMeshP_save, enabling I/O from parallel processes.
+ * For now, individual implementations will support different sets of
+ * options; Tim and Ken will work to unify the options by SC08.
+ */
+
+/* \brief iMeshP_load: function to populate a mesh instance and
+ * a partition by reading data from files.
+ * The application creates both the mesh instance and the partition
+ * handle before calling iMeshP_load. iMeshP_load then reads the
+ * specified file, inserts entities into the mesh instance, constructs
+ * parts within the partition, and inserts entities into the parts.
+ * Optional capabilities of iMeshP_load include computing an initial
+ * partition (e.g., if a serial mesh file without part assignments is read)
+ * and creating ghost entities as requested by the application.
+ * Options allow n>=1 files on p processes.
+ */
+
+void iMeshP_load(iMesh_Instance instance,
+ const iMeshP_PartitionHandle partition,
+ const iBase_EntitySetHandle entity_set_handle,
+ const char *name,
+ const char *options,
+ int *err,
+ int name_len,
+ int options_len);
+
+/* \brief iMeshP_save: function to write data from a mesh instance and
+ * a partition to files.
+ * iMeshP_save writes mesh and partition data to the
+ * specified file.
+ * Options allow n>=1 files on p processes.
+ */
+void iMeshP_save(iMesh_Instance instance,
+ const iMeshP_PartitionHandle partition,
+ const iBase_EntitySetHandle entity_set_handle,
+ const char *name,
+ const char *options,
+ int *err,
+ const int name_len,
+ int options_len);
+
+
/*
------------------------------------------------
Major Items left to do:
@@ -1004,6 +1113,7 @@
same time. Designating one partition as "active" would store data
with respect to only one partition.
- File I/O support.
+ Need common set of options to allow interoperability.
Support single files, N << P files on P processes, and P files.
Support reading and writing partition information.
Support initial parallel partitioning of serial file data.
@@ -1027,6 +1137,10 @@
- iMeshP_getOwnerCopy could be achieved by calling iMeshP_getOwnerPart
followed by iMeshP_getCopyOnPart. Do we want to keep iMeshP_getOwnerCopy?
+- Need function to receive tag data from part-boundary entities in owner.
+ Possible options: return the tag data values received directly, or
+ include a mathematical operation (similar to MPI_SUM). 9/15/08
+
------------------------------------------------
Comments and resolved questions:
@@ -1223,10 +1337,10 @@
will return only itself and its owner in getCopies; part-boundary
entities will return copies on other parts as well.
- Tim envisions applications (e.g., FETI methods) updating tag data
-in their ghosts that they would like to accumulate back to the
+in their copies that they would like to accumulate back to the
owner. Xiaolin said that he writes in his ghosts, but doesn't send
-those values back to the owner. Currently, we have the ability only
-to send tag data from owners to ghosts. Tim will look at this issue
+those values back to the owner. Currently, we have the ability
+to send tag data only from owners to ghosts. Tim will look at this issue
and propose a solution.
Communication:
@@ -1260,7 +1374,14 @@
CVS File Information
$RCSfile: DraftInterface.h,v $
$Author: kddevin $
- $Date: 2008/07/24 20:08:12 $
- $Revision: 1.27 $
+ $Date: 2008/09/15 17:50:05 $
+ $Revision: 1.31 $
------------------------------------------------
*/
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif /* defined(iMeshP_h) */
+
Modified: MOAB/trunk/tools/iMesh/iMeshP_protos.h
===================================================================
--- MOAB/trunk/tools/iMesh/iMeshP_protos.h 2008-10-02 19:48:09 UTC (rev 2126)
+++ MOAB/trunk/tools/iMesh/iMeshP_protos.h 2008-10-02 20:37:30 UTC (rev 2127)
@@ -1,25 +1,71 @@
#include "MBCN_FCDefs.h"
-
#ifdef FC_FUNC_
-
-#define iMesh_getErrorType FC_FUNC_(imesh_geterrortype, IMESH_GETERRORTYPE)
-#define iMeshP_getNumParts FC_FUNC_(imeshp_getnumparts, IMESHP_GETNUMPARTS)
-#define iMeshP_getRankOfPart FC_FUNC_(imeshp_getrankofpart, IMESHP_GETRANKOFPART)
-#define iMeshP_getRankOfPartArr FC_FUNC_(imeshp_getrankofpartarr, IMESHP_GETRANKOFPARTARR)
-#define iMeshP_getPartsOnRank FC_FUNC_(imeshp_getpartsonrank, IMESHP_GETPARTSONRANK)
-#define iMeshP_getPartsArrOnRank FC_FUNC_(imeshp_getpartsarronrank, IMESHP_GETPARTSARRONRANK)
-#define iMeshP_getNumOfTypeAll FC_FUNC_(imeshp_getnumoftypeall, IMESHP_GETNUMOFTYPEALL)
-#define iMeshP_getNumOfTopoAll FC_FUNC_(imeshp_getnumoftopoall, IMESHP_GETNUMOFTOPOALL)
-#define iMeshP_testPart FC_FUNC_(imeshp_testpart, IMESHP_TESTPART)
-#define iMeshP_getEntOwnerPart FC_FUNC_(imeshp_getentownerpart, IMESHP_GETENTOWNERPART)
-#define iMeshP_getEntOwnerPartArr FC_FUNC_(imeshp_getentownerpartarr, IMESHP_GETENTOWNERPARTARR)
-#define iMeshP_isEntOwner FC_FUNC_(imeshp_isentowner, IMESHP_ISENTOWNER)
-#define iMeshP_isEntOwnerArr FC_FUNC_(imeshp_isentownerarr, IMESHP_ISENTOWNERARR)
-#define iMeshP_getEntStatus FC_FUNC_(imeshp_getentstatus, IMESHP_GETENTSTATUS)
-#define iMeshP_getEntStatusArr FC_FUNC_(imeshp_getentstatusarr, IMESHP_GETENTSTATUSARR)
-#define iMeshP_getNumCopies FC_FUNC_(imeshp_getnumcopies, IMESHP_GETNUMCOPIES)
-#define iMeshP_getCopies FC_FUNC_(imeshp_getcopies, IMESHP_GETCOPIES)
-
+#define iMeshP_createPartitionAll FC_FUNC_(imeshp_createpartitionall, IMESHP_CREATEPARTITIONALL)
+#define iMeshP_destroyPartitionAll FC_FUNC_(imeshp_destroypartitionall, IMESHP_DESTROYPARTITIONALL)
+#define iMeshP_getPartitionComm FC_FUNC_(imeshp_getpartitioncomm, IMESHP_GETPARTITIONCOMM)
+#define iMeshP_syncPartitionAll FC_FUNC_(imeshp_syncpartitionall, IMESHP_SYNCPARTITIONALL)
+#define iMeshP_getNumPartitions FC_FUNC_(imeshp_getnumpartitions, IMESHP_GETNUMPARTITIONS)
+#define iMeshP_getPartitions FC_FUNC_(imeshp_getpartitions, IMESHP_GETPARTITIONS)
+#define iMeshP_getNumGlobalParts FC_FUNC_(imeshp_getnumglobalparts, IMESHP_GETNUMGLOBALPARTS)
+#define iMeshP_getNumLocalParts FC_FUNC_(imeshp_getnumlocalparts, IMESHP_GETNUMLOCALPARTS)
+#define iMeshP_getLocalParts FC_FUNC_(imeshp_getlocalparts, IMESHP_GETLOCALPARTS)
+#define iMeshP_getRankOfPart FC_FUNC_(imeshp_getrankofpart, IMESHP_GETRANKOFPART)
+#define iMeshP_getRankOfPartArr FC_FUNC_(imeshp_getrankofpartarr, IMESHP_GETRANKOFPARTARR)
+#define iMeshP_getNumOfTypeAll FC_FUNC_(imeshp_getnumoftypeall, IMESHP_GETNUMOFTYPEALL)
+#define iMeshP_getNumOfTopoAll FC_FUNC_(imeshp_getnumoftopoall, IMESHP_GETNUMOFTOPOALL)
+#define iMeshP_createPart FC_FUNC_(imeshp_createpart, IMESHP_CREATEPART)
+#define iMeshP_destroyPart FC_FUNC_(imeshp_destroypart, IMESHP_DESTROYPART)
+#define iMeshP_getPartFromPartHandle FC_FUNC_(imeshp_getpartfromparthandle, IMESHP_GETPARTFROMPARTHANDLE)
+#define iMeshP_getPartFromPartHandlesArr FC_FUNC_(imeshp_getpartfromparthandlesarr, IMESHP_GETPARTFROMPARTHANDLESARR)
+#define iMeshP_getPartHandleFromPart FC_FUNC_(imeshp_getparthandlefrompart, IMESHP_GETPARTHANDLEFROMPART)
+#define iMeshP_getPartHandlesFromPartsArr FC_FUNC_(imeshp_getparthandlesfrompartsarr, IMESHP_GETPARTHANDLESFROMPARTSARR)
+#define iMeshP_getNumPartNbors FC_FUNC_(imeshp_getnumpartnbors, IMESHP_GETNUMPARTNBORS)
+#define iMeshP_getNumPartNborsArr FC_FUNC_(imeshp_getnumpartnborsarr, IMESHP_GETNUMPARTNBORSARR)
+#define iMeshP_getPartNbors FC_FUNC_(imeshp_getpartnbors, IMESHP_GETPARTNBORS)
+#define iMeshP_getPartNborsArr FC_FUNC_(imeshp_getpartnborsarr, IMESHP_GETPARTNBORSARR)
+#define iMeshP_getNumPartBdryEnts FC_FUNC_(imeshp_getnumpartbdryents, IMESHP_GETNUMPARTBDRYENTS)
+#define iMeshP_getPartBdryEnts FC_FUNC_(imeshp_getpartbdryents, IMESHP_GETPARTBDRYENTS)
+#define iMeshP_initPartBdryEntIter FC_FUNC_(imeshp_initpartbdryentiter, IMESHP_INITPARTBDRYENTITER)
+#define iMeshP_initPartBdryEntArrIter FC_FUNC_(imeshp_initpartbdryentarriter, IMESHP_INITPARTBDRYENTARRITER)
+#define iMeshP_getNumOfType FC_FUNC_(imeshp_getnumoftype, IMESHP_GETNUMOFTYPE)
+#define iMeshP_getNumOfTopo FC_FUNC_(imeshp_getnumoftopo, IMESHP_GETNUMOFTOPO)
+#define iMeshP_getAllVtxCoords FC_FUNC_(imeshp_getallvtxcoords, IMESHP_GETALLVTXCOORDS)
+#define iMeshP_getVtxCoordIndex FC_FUNC_(imeshp_getvtxcoordindex, IMESHP_GETVTXCOORDINDEX)
+#define iMeshP_getEntities FC_FUNC_(imeshp_getentities, IMESHP_GETENTITIES)
+#define iMeshP_getAdjEntities FC_FUNC_(imeshp_getadjentities, IMESHP_GETADJENTITIES)
+#define iMeshP_initEntIter FC_FUNC_(imeshp_initentiter, IMESHP_INITENTITER)
+#define iMeshP_initEntArrIter FC_FUNC_(imeshp_initentarriter, IMESHP_INITENTARRITER)
+#define iMeshP_getEntOwnerPart FC_FUNC_(imeshp_getentownerpart, IMESHP_GETENTOWNERPART)
+#define iMeshP_getEntOwnerPartArr FC_FUNC_(imeshp_getentownerpartarr, IMESHP_GETENTOWNERPARTARR)
+#define iMeshP_isEntOwner FC_FUNC_(imeshp_isentowner, IMESHP_ISENTOWNER)
+#define iMeshP_isEntOwnerArr FC_FUNC_(imeshp_isentownerarr, IMESHP_ISENTOWNERARR)
+#define iMeshP_getEntStatus FC_FUNC_(imeshp_getentstatus, IMESHP_GETENTSTATUS)
+#define iMeshP_getEntStatusArr FC_FUNC_(imeshp_getentstatusarr, IMESHP_GETENTSTATUSARR)
+#define iMeshP_getNumCopies FC_FUNC_(imeshp_getnumcopies, IMESHP_GETNUMCOPIES)
+#define iMeshP_getCopyParts FC_FUNC_(imeshp_getcopyparts, IMESHP_GETCOPYPARTS)
+#define iMeshP_getCopies FC_FUNC_(imeshp_getcopies, IMESHP_GETCOPIES)
+#define iMeshP_getCopyOnPart FC_FUNC_(imeshp_getcopyonpart, IMESHP_GETCOPYONPART)
+#define iMeshP_getOwnerCopy FC_FUNC_(imeshp_getownercopy, IMESHP_GETOWNERCOPY)
+#define iMeshP_Wait FC_FUNC_(imeshp_wait, IMESHP_WAIT)
+#define iMeshP_WaitAny FC_FUNC_(imeshp_waitany, IMESHP_WAITANY)
+#define iMeshP_WaitAll FC_FUNC_(imeshp_waitall, IMESHP_WAITALL)
+#define iMeshP_WaitEnt FC_FUNC_(imeshp_waitent, IMESHP_WAITENT)
+#define iMeshP_Test FC_FUNC_(imeshp_test, IMESHP_TEST)
+#define iMeshP_pollForRequests FC_FUNC_(imeshp_pollforrequests, IMESHP_POLLFORREQUESTS)
+#define iMeshP_exchEntArrToPartsAll FC_FUNC_(imeshp_exchentarrtopartsall, IMESHP_EXCHENTARRTOPARTSALL)
+#define iMeshP_migrateEntity FC_FUNC_(imeshp_migrateentity, IMESHP_MIGRATEENTITY)
+#define iMeshP_updateVtxCoords FC_FUNC_(imeshp_updatevtxcoords, IMESHP_UPDATEVTXCOORDS)
+#define iMeshP_replaceOnPartBdry FC_FUNC_(imeshp_replaceonpartbdry, IMESHP_REPLACEONPARTBDRY)
+#define iMeshP_addGhostOf FC_FUNC_(imeshp_addghostof, IMESHP_ADDGHOSTOF)
+#define iMeshP_rmvGhostOf FC_FUNC_(imeshp_rmvghostof, IMESHP_RMVGHOSTOF)
+#define iMeshP_syncMeshAll FC_FUNC_(imeshp_syncmeshall, IMESHP_SYNCMESHALL)
+#define iMeshP_pushTags FC_FUNC_(imeshp_pushtags, IMESHP_PUSHTAGS)
+#define iMeshP_pushTagsEnt FC_FUNC_(imeshp_pushtagsent, IMESHP_PUSHTAGSENT)
+#define iMeshP_iPushTags FC_FUNC_(imeshp_ipushtags, IMESHP_IPUSHTAGS)
+#define iMeshP_iPushTagsEnt FC_FUNC_(imeshp_ipushtagsent, IMESHP_IPUSHTAGSENT)
+#define iMeshP_createGhostEnts FC_FUNC_(imeshp_createghostents, IMESHP_CREATEGHOSTENTS)
+#define iMeshP_deleteGhostEnts FC_FUNC_(imeshp_deleteghostents, IMESHP_DELETEGHOSTENTS)
+#define iMeshP_ghostEntInfo FC_FUNC_(imeshp_ghostentinfo, IMESHP_GHOSTENTINFO)
+#define iMeshP_load FC_FUNC_(imeshp_load, IMESHP_LOAD)
+#define iMeshP_save FC_FUNC_(imeshp_save, IMESHP_SAVE)
#endif
-
-
More information about the moab-dev
mailing list