Hi, Harold. The ITAPS Parallel Interface subcommittee has a question for you. We have defined partitions to be assignments of entities to subsets, and parts to be those subsets. We assume that a mesh instance may have several partitions, but a partition contains entities from only one mesh instance. We also assume a processor may have many parts, but each part is contained completely within only one processor. We identify partitions with a (mesh instance, partition handle) pair. That is, functions that operate on partitions would take a mesh instance and a partition handle as input arguments. Similarly, within a processor, we would like to identify parts with a (mesh instance, part handle) pair so that we can overload many of the iMesh EntitySet functions with part handles. That is, we would like to allow, say, iMesh_getNumOfType to accept either an entity set handle OR a part handle, and return the number of entities of a given type in the entity set or the part, respectively. There was some concern, however, that (1) some implementations may not be able to distinguish between part and entity set handles, and (2) some implementations might not be able to uniquely identify parts given only the mesh instance and part handle (e.g., they might also need the partition handle). The alternative to overloading the EntitySet argument is to define many new interface functions that take the mesh instance, partition handle, and part handle as input and duplicate the EntitySet functionality on parts. Within the subcommittee, we agreed that we could accept the (mesh instance, part handle) pair only if your implementations could support it. So, you wield the power now. :) Would the (mesh instance, part handle) pair be sufficient for uniquely identify parts on a processor? Thanks. Karen