fathom/moab-docs-develop/iMeshP__MOAB_8cpp_source.html

00001 #include "moab/MOABConfig.h"
00002 #include "iMeshP_extensions.h"
00003 #include "iMesh_MOAB.hpp"
00004 #include "moab/Core.hpp"
00005 #include "moab/Range.hpp"
00006 #include "moab/CN.hpp"
00007 #include "moab/MeshTopoUtil.hpp"
00008 #include "moab/FileOptions.hpp"
00009 #include "moab/ParallelComm.hpp"
00010 #include "MBParallelConventions.h"
00011 #include "MBIter.hpp"
00012
00013 #define IS_BUILDING_MB
00014 #include "Internals.hpp"
00015 #undef IS_BUILDING_MB
00016
00017 #include <cassert>
00018 #include <sstream>
00019
00020 #ifdef MOAB_HAVE_MPI
00021 #include "moab_mpi.h"
00022 #endif
00023
00024 using namespace moab;
00025
00026 /********************* Error Handling **************************/
00027
00028 #define FIXME printf( "Warning: function has incomplete implementation: %s\n", __func__ )
00029
00030 /******** Type-safe casting between MOAB and ITAPS types *********/
00031
00032 #ifndef MOAB_TEMPLATE_FUNC_SPECIALIZATION
00033 // if no template specialization, disable some type checking
00034 template < typename T, typename S >
00035 inline T itaps_cast( S handle )
00036 {
00037     assert( sizeof( S ) >= sizeof( T ) );
00038     return reinterpret_cast< T >( handle );
00039 }
00040 #else
00041
00042 // basic template method : only works to cast to equivalent types (no-op)
00043 template < typename T, typename S >
00044 inline T itaps_cast( S h )
00045 {
00046     return h;
00047 }
00048 // verify size and do reinterpret cast
00049 template < typename T >
00050 inline T itaps_cast_internal_( EntityHandle h )
00051 {
00052     assert( sizeof( T ) >= sizeof( EntityHandle ) );
00053     return reinterpret_cast< T >( h );
00054 }
00055 // verify size and do reinterpret cast
00056 template < typename T >
00057 inline EntityHandle* itaps_cast_ptr_( T* h )
00058 {
00059     assert( sizeof( T ) == sizeof( EntityHandle ) );
00060     return reinterpret_cast< EntityHandle* >( h );
00061 }
00062 // verify size and do reinterpret cast
00063 template < typename T >
00064 inline const EntityHandle* itaps_cast_const_ptr_( const T* h )
00065 {
00066     assert( sizeof( T ) == sizeof( EntityHandle ) );
00067     return reinterpret_cast< const EntityHandle* >( h );
00068 }
00069 // verify set-type handle before cast
00070 template < typename T >
00071 inline T itaps_set_cast_( EntityHandle h )
00072 {
00073     assert( TYPE_FROM_HANDLE( h ) == MBENTITYSET );
00074     return itaps_cast_internal_< T >( h );
00075 }
00076
00077 // define conversion routines between itaps handle and EntityHandle types
00078 #define DECLARE_ALLOWED_ITAPS_CONVERSION( ITAPS_HANDLE_TYPE )                                       \
00079     template <>                                                                                     \
00080     inline ITAPS_HANDLE_TYPE itaps_cast< ITAPS_HANDLE_TYPE, EntityHandle >( EntityHandle h )        \
00081     {                                                                                               \
00082         return itaps_cast_internal_< ITAPS_HANDLE_TYPE >( h );                                      \
00083     }                                                                                               \
00084                                                                                                     \
00085     template <>                                                                                     \
00086     inline EntityHandle itaps_cast< EntityHandle, ITAPS_HANDLE_TYPE >( ITAPS_HANDLE_TYPE handle )   \
00087     {                                                                                               \
00088         return reinterpret_cast< EntityHandle >( handle );                                          \
00089     }                                                                                               \
00090                                                                                                     \
00091     template <>                                                                                     \
00092     inline EntityHandle* itaps_cast< EntityHandle*, ITAPS_HANDLE_TYPE* >( ITAPS_HANDLE_TYPE * ptr ) \
00093     {                                                                                               \
00094         return itaps_cast_ptr_( ptr );                                                              \
00095     }                                                                                               \
00096                                                                                                     \
00097     template <>                                                                                     \
00098     inline const EntityHandle* itaps_cast< const EntityHandle*, const ITAPS_HANDLE_TYPE* >(         \
00099         const ITAPS_HANDLE_TYPE* ptr )                                                              \
00100     {                                                                                               \
00101         return itaps_cast_const_ptr_( ptr );                                                        \
00102     }
00103
00104 // define conversion routines between itaps handle and EntityHandle types
00105 // but limit to EntityHandle for MBENTITYSET type.
00106 #define DECLARE_ALLOWED_ITAPS_SET_CONVERSION( ITAPS_HANDLE_TYPE )                                   \
00107     template <>                                                                                     \
00108     inline ITAPS_HANDLE_TYPE itaps_cast< ITAPS_HANDLE_TYPE, EntityHandle >( EntityHandle h )        \
00109     {                                                                                               \
00110         return itaps_set_cast_< ITAPS_HANDLE_TYPE >( h );                                           \
00111     }                                                                                               \
00112                                                                                                     \
00113     template <>                                                                                     \
00114     inline EntityHandle itaps_cast< EntityHandle, ITAPS_HANDLE_TYPE >( ITAPS_HANDLE_TYPE handle )   \
00115     {                                                                                               \
00116         return reinterpret_cast< EntityHandle >( handle );                                          \
00117     }                                                                                               \
00118                                                                                                     \
00119     template <>                                                                                     \
00120     inline EntityHandle* itaps_cast< EntityHandle*, ITAPS_HANDLE_TYPE* >( ITAPS_HANDLE_TYPE * ptr ) \
00121     {                                                                                               \
00122         return itaps_cast_ptr_( ptr );                                                              \
00123     }                                                                                               \
00124                                                                                                     \
00125     template <>                                                                                     \
00126     inline const EntityHandle* itaps_cast< const EntityHandle*, const ITAPS_HANDLE_TYPE* >(         \
00127         const ITAPS_HANDLE_TYPE* ptr )                                                              \
00128     {                                                                                               \
00129         return itaps_cast_const_ptr_( ptr );                                                        \
00130     }
00131
00132 DECLARE_ALLOWED_ITAPS_SET_CONVERSION( iMeshP_PartitionHandle )
00133 // DECLARE_ALLOWED_ITAPS_SET_CONVERSION( iMeshP_PartHandle )
00134 DECLARE_ALLOWED_ITAPS_SET_CONVERSION( iBase_EntitySetHandle )
00135 DECLARE_ALLOWED_ITAPS_CONVERSION( iBase_EntityHandle )
00136
00137 template <>
00138 inline Tag itaps_cast< Tag, iBase_TagHandle >( iBase_TagHandle h )
00139 {
00140     return reinterpret_cast< Tag >( h );
00141 }
00142 template <>
00143 inline iBase_TagHandle itaps_cast< iBase_TagHandle, Tag >( Tag h )
00144 {
00145     return reinterpret_cast< iBase_TagHandle >( h );
00146 }
00147
00148 #endif
00149
00150 #define PCOMM ParallelComm::get_pcomm( MOABI, itaps_cast< EntityHandle >( partition_handle ) )
00151
00152 /*** static function implemented in iMesh_MOAB.cpp ***/
00153
00154 // Need a different function name for Tag because (currently)
00155 // both Tag and iBase_EntityHandle are void**.
00156 iBase_TagHandle itaps_tag_cast( Tag t )
00157 {
00158     assert( sizeof( iBase_TagHandle ) >= sizeof( Tag ) );
00159     return reinterpret_cast< iBase_TagHandle >( t );
00160 }
00161
00162 /********************* ITAPS arrays **************************/
00163
00164 // Handle returning Range in ITAPS array (do ALLOCATE_ARRAY and copy).
00165 #define RANGE_TO_ITAPS_ARRAY( RANGE, NAME )                                                        \
00166     do                                                                                             \
00167     {                                                                                              \
00168         ALLOC_CHECK_ARRAY_NOFAIL( NAME, ( RANGE ).size() );                                        \
00169         std::copy( ( RANGE ).begin(), ( RANGE ).end(), itaps_cast< EntityHandle* >( *( NAME ) ) ); \
00170     } while( false )
00171
00172 static inline ErrorCode get_entities( Interface* iface, EntityHandle set, int type, int topology, Range& entities )
00173 {
00174     if( topology != iMesh_ALL_TOPOLOGIES )
00175         return iface->get_entities_by_type( set, mb_topology_table[topology], entities );
00176     else if( type != iBase_ALL_TYPES )
00177         return iface->get_entities_by_dimension( set, type, entities );
00178     else
00179         return iface->get_entities_by_handle( set, entities );
00180 }
00181
00182 /*
00183 static inline ErrorCode remove_not_owned( ParallelComm* pcomm, Range& ents )
00184 {
00185   ErrorCode rval;
00186
00187   std::vector<unsigned char> pstatus(ents.size());
00188   rval = pcomm->get_moab()->tag_get_data(pcomm->pstatus_tag(), ents, &pstatus[0]);
00189   if (MB_SUCCESS != rval)
00190     return rval;
00191
00192   Range::iterator i = ents.begin();
00193   std::vector<unsigned char>::const_iterator j;
00194   for (j = pstatus.begin(); j != pstatus.end(); ++j) {
00195     if (*j & PSTATUS_NOT_OWNED)
00196       i = ents.erase( i );
00197     else
00198       ++i;
00199   }
00200
00201   return MB_SUCCESS;
00202 }
00203 */
00204
00205 static inline ErrorCode count_owned( ParallelComm* pcomm, const Range& ents, int& n )
00206 {
00207     ErrorCode rval;
00208     n = 0;
00209
00210     std::vector< unsigned char > pstatus( ents.size() );
00211     rval = pcomm->get_moab()->tag_get_data( pcomm->pstatus_tag(), ents, &pstatus[0] );
00212     if( MB_SUCCESS != rval ) return rval;
00213
00214     std::vector< unsigned char >::const_iterator j;
00215     for( j = pstatus.begin(); j != pstatus.end(); ++j )
00216         if( !( *j & PSTATUS_NOT_OWNED ) ) ++n;
00217
00218     return MB_SUCCESS;
00219 }
00220
00221 static void set_intersection_query( iMesh_Instance instance,
00222                                     iMeshP_PartHandle set1,
00223                                     iBase_EntitySetHandle set2,
00224                                     int type,
00225                                     int topo,
00226                                     Range& result,
00227                                     int* err )
00228 {
00229     ErrorCode rval;
00230
00231     if( !set1 )
00232     {
00233         rval = get_entities( MOABI, itaps_cast< EntityHandle >( set2 ), type, topo, result );CHKERR( rval, "Invalid Part handle" );
00234     }
00235     else if( !set2 )
00236     {
00237         rval = get_entities( MOABI, itaps_cast< EntityHandle >( set1 ), type, topo, result );CHKERR( rval, "Invalid set handle" );
00238     }
00239     else
00240     {
00241         Range r1, r2;
00242         rval = get_entities( MOABI, itaps_cast< EntityHandle >( set1 ), type, topo, r1 );CHKERR( rval, "Invalid Part handle" );
00243         rval = get_entities( MOABI, itaps_cast< EntityHandle >( set2 ), type, topo, r2 );CHKERR( rval, "Invalid set handle" );
00244         result.merge( intersect( r1, r2 ) );
00245     }
00246
00247     RETURN( iBase_SUCCESS );
00248 }
00249
00250 /********************* Iterators **************************/
00251
00252 static ErrorCode get_boundary_entities( ParallelComm* pcomm,
00253                                         EntityHandle part_handle,
00254                                         int entity_type,
00255                                         int entity_topology,
00256                                         int adj_part_id,
00257                                         Range& entities_out )
00258 {
00259     int* adj_part_id_ptr = ( adj_part_id == iMeshP_ALL_PARTS ) ? 0 : &adj_part_id;
00260
00261     Range iface_sets;
00262     ErrorCode rval = pcomm->get_interface_sets( part_handle, iface_sets, adj_part_id_ptr );
00263     if( MB_SUCCESS != rval ) return rval;
00264
00265     for( Range::iterator i = iface_sets.begin(); i != iface_sets.end(); ++i )
00266     {
00267         rval = get_entities( pcomm->get_moab(), *i, entity_type, entity_topology, entities_out );
00268         if( MB_SUCCESS != rval ) return rval;
00269     }
00270
00271     return MB_SUCCESS;
00272 }
00273
00274 class PartBoundaryIter : public MBRangeIter
00275 {
00276   private:
00277     ParallelComm* pComm;
00278     int adjPart;
00279
00280   public:
00281     inline PartBoundaryIter( ParallelComm* pcomm,
00282                              EntityHandle part_handle,
00283                              iBase_EntityType entity_type,
00284                              iMesh_EntityTopology entity_topology,
00285                              int adj_part_id,
00286                              int array_sz )
00287         : MBRangeIter( entity_type, entity_topology, part_handle, array_sz ), pComm( pcomm ), adjPart( adj_part_id )
00288     {
00289     }
00290
00291     virtual ErrorCode reset( Interface* )
00292     {
00293         iterData.clear();
00294         ErrorCode result = get_boundary_entities( pComm, entSet, entType, entTopo, adjPart, iterData );
00295         iterPos          = iterData.begin();
00296         return result;
00297     }
00298 };
00299
00300 template < class Container >
00301 class SetIntersectIter : public MBIter< Container >
00302 {
00303   private:
00304     EntityHandle otherSet;
00305
00306   public:
00307     SetIntersectIter( iBase_EntityType type,
00308                       iMesh_EntityTopology topology,
00309                       EntityHandle set,
00310                       EntityHandle other_set,
00311                       int array_sz )
00312         : MBIter< Container >( type, topology, set, array_sz ), otherSet( other_set )
00313     {
00314     }
00315     virtual ~SetIntersectIter() {}
00316
00317     inline ErrorCode intersect_with_set( Interface* mb, Range& range )
00318     {
00319         Range tmp;
00320         ErrorCode result;
00321         result = mb->get_entities_by_handle( otherSet, tmp );
00322         range  = intersect( range, tmp );
00323         return result;
00324     }
00325
00326     inline ErrorCode intersect_with_set( Interface* mb, std::vector< EntityHandle >& list )
00327     {
00328         size_t w = 0;
00329         for( size_t r = 0; r < list.size(); ++r )
00330         {
00331             if( mb->contains_entities( otherSet, &list[r], 1 ) ) list[w++] = list[r];
00332         }
00333         list.resize( w );
00334         return MB_SUCCESS;
00335     }
00336
00337     virtual ErrorCode reset( Interface* mb )
00338     {
00339         ErrorCode result = MBIter< Container >::reset( mb );
00340         if( MB_SUCCESS != result ) return result;
00341
00342         result                       = intersect_with_set( mb, MBIter< Container >::iterData );
00343         MBIter< Container >::iterPos = MBIter< Container >::iterData.begin();
00344         return result;
00345     }
00346 };
00347
00348 /********************* iMeshP API **************************/
00349
00350 #ifdef __cplusplus
00351 extern "C" {
00352 #endif
00353
00354 void iMeshP_createPartitionAll( iMesh_Instance instance,
00355                                 /*in*/ MPI_Comm communicator,
00356                                 /*out*/ iMeshP_PartitionHandle* partition_handle,
00357                                 int* err )
00358 {
00359     *partition_handle = 0;
00360
00361     Tag prtn_tag;
00362     ErrorCode rval = MOABI->tag_get_handle( PARALLEL_PARTITIONING_TAG_NAME, 1, MB_TYPE_INTEGER, prtn_tag,
00363                                             MB_TAG_SPARSE | MB_TAG_CREAT );CHKERR( rval, "tag creation failed" );
00364
00365     EntityHandle handle;
00366     rval = MOABI->create_meshset( MESHSET_SET, handle );CHKERR( rval, "set creation failed" );
00367     ParallelComm* pcomm = ParallelComm::get_pcomm( MOABI, handle, &communicator );
00368     if( !pcomm )
00369     {
00370         MOABI->delete_entities( &handle, 1 );
00371         RETURN( iBase_FAILURE );
00372     }
00373
00374     // set the value of pcomm id, to the partitioning tag, although this is not used
00375     // we just need the tag to be set
00376     int pid = pcomm->get_id();
00377     rval    = MOABI->tag_set_data( prtn_tag, &handle, 1, &pid );CHKERR( rval, "tag creation failed" );
00378
00379     *partition_handle = itaps_cast< iMeshP_PartitionHandle >( handle );
00380     RETURN( iBase_SUCCESS );
00381 }
00382
00383 void iMeshP_destroyPartitionAll( iMesh_Instance instance, iMeshP_PartitionHandle partition_handle, int* err )
00384 {
00385     ParallelComm* pcomm = PCOMM;
00386     if( pcomm ) delete pcomm;
00387     EntityHandle handle = itaps_cast< EntityHandle >( partition_handle );
00388     ErrorCode rval      = MOABI->delete_entities( &handle, 1 );CHKERR( rval, "entity deletion failed" );
00389     RETURN( iBase_SUCCESS );
00390 }
00391
00392 void iMeshP_getPartIdFromPartHandle( iMesh_Instance instance,
00393                                      const iMeshP_PartitionHandle partition_handle,
00394                                      const iMeshP_PartHandle part_handle,
00395                                      iMeshP_Part* part_id,
00396                                      int* err )
00397 {
00398     int junk1 = 1, junk2;
00399     iMeshP_getPartIdsFromPartHandlesArr( instance, partition_handle, &part_handle, 1, &part_id, &junk1, &junk2, err );
00400 }
00401
00402 void iMeshP_getPartHandleFromPartId( iMesh_Instance instance,
00403                                      const iMeshP_PartitionHandle partition_handle,
00404                                      iMeshP_Part part_id,
00405                                      iMeshP_PartHandle* part_handle,
00406                                      int* err )
00407 {
00408     int junk1 = 1, junk2;
00409     iMeshP_getPartHandlesFromPartsIdsArr( instance, partition_handle, &part_id, 1, &part_handle, &junk1, &junk2, err );
00410 }
00411
00412 void iMeshP_getPartIdsFromPartHandlesArr( iMesh_Instance instance,
00413                                           const iMeshP_PartitionHandle partition_handle,
00414                                           const iMeshP_PartHandle* part_handles,
00415                                           const int part_handles_size,
00416                                           iMeshP_Part** part_ids,
00417                                           int* part_ids_allocated,
00418                                           int* part_ids_size,
00419                                           int* err )
00420 {
00421     ErrorCode rval;
00422     ParallelComm* pcomm = PCOMM;
00423     ALLOC_CHECK_ARRAY( part_ids, part_handles_size );
00424     for( int i = 0; i < part_handles_size; ++i )
00425     {
00426         int id;
00427         rval             = pcomm->get_part_id( itaps_cast< EntityHandle >( part_handles[i] ), id );
00428         ( *part_ids )[i] = id;CHKERR( rval, "error getting part id" );
00429     }
00430     KEEP_ARRAY( part_ids );
00431     RETURN( iBase_SUCCESS );
00432 }
00433
00434 void iMeshP_getPartHandlesFromPartsIdsArr( iMesh_Instance instance,
00435                                            const iMeshP_PartitionHandle partition_handle,
00436                                            const iMeshP_Part* part_ids,
00437                                            const int part_ids_size,
00438                                            iMeshP_PartHandle** part_handles,
00439                                            int* part_handles_allocated,
00440                                            int* part_handles_size,
00441                                            int* err )
00442 {
00443     ErrorCode rval;
00444     ParallelComm* pcomm = PCOMM;
00445     ALLOC_CHECK_ARRAY( part_handles, part_ids_size );
00446     for( int i = 0; i < part_ids_size; ++i )
00447     {
00448         EntityHandle handle;
00449         rval = pcomm->get_part_handle( part_ids[i], handle );CHKERR( rval, "error getting part handle" );
00450         ( *part_handles )[i] = itaps_cast< iMeshP_PartHandle >( handle );
00451     }
00452     KEEP_ARRAY( part_handles );
00453     RETURN( iBase_SUCCESS );
00454 }
00455
00456 void iMeshP_getPartitionComm( iMesh_Instance instance,
00457                               iMeshP_PartitionHandle partition_handle,
00458                               MPI_Comm* communicator_out,
00459                               int* err )
00460 {
00461     ParallelComm* pcomm = PCOMM;
00462     if( !pcomm ) RETURN( iBase_FAILURE );
00463     *communicator_out = pcomm->proc_config().proc_comm();
00464     RETURN( iBase_SUCCESS );
00465 }
00466
00467 void iMeshP_syncPartitionAll( iMesh_Instance instance, iMeshP_PartitionHandle partition_handle, int* err )
00468 {
00469     ParallelComm* pcomm = PCOMM;
00470     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
00471     ErrorCode rval = pcomm->collective_sync_partition();CHKERR( rval, "collective sync failed" );
00472     RETURN( iBase_SUCCESS );
00473 }
00474
00475 void iMeshP_getNumPartitions( iMesh_Instance instance, int* num_partitions_out, int* err )
00476 {
00477     std::vector< ParallelComm* > pcomms;
00478     ErrorCode rval = ParallelComm::get_all_pcomm( MOABI, pcomms );CHKERR( rval, "Internal error retreiving PComms" );
00479
00480     std::vector< ParallelComm* >::iterator i;
00481     *num_partitions_out = 0;
00482     for( i = pcomms.begin(); i != pcomms.end(); ++i )
00483         if( ( *i )->get_partitioning() ) ( *num_partitions_out )++;
00484
00485     RETURN( iBase_SUCCESS );
00486 }
00487
00488 void iMeshP_getPartitions( iMesh_Instance instance,
00489                            iMeshP_PartitionHandle** partition_handle,
00490                            int* partition_handle_allocated,
00491                            int* partition_handle_size,
00492                            int* err )
00493 {
00494     std::vector< ParallelComm* > pcomms;
00495     ErrorCode rval = ParallelComm::get_all_pcomm( MOABI, pcomms );CHKERR( rval, "Internal error retreiving PComms" );
00496
00497     std::vector< ParallelComm* >::iterator i;
00498     int count = 0;
00499     for( i = pcomms.begin(); i != pcomms.end(); ++i )
00500         if( ( *i )->get_partitioning() ) ++count;
00501     ALLOC_CHECK_ARRAY_NOFAIL( partition_handle, count );
00502
00503     *partition_handle_size = 0;
00504     for( i = pcomms.begin(); i != pcomms.end(); ++i )
00505         if( ( *i )->get_partitioning() )
00506             ( *partition_handle )[( *partition_handle_size )++] =
00507                 itaps_cast< iMeshP_PartitionHandle >( ( *i )->get_partitioning() );
00508
00509     RETURN( iBase_SUCCESS );
00510 }
00511
00512 void iMeshP_getNumGlobalParts( iMesh_Instance instance,
00513                                const iMeshP_PartitionHandle partition_handle,
00514                                int* num_global_part,
00515                                int* err )
00516 {
00517     ParallelComm* pcomm = PCOMM;
00518     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
00519
00520     ErrorCode rval = pcomm->get_global_part_count( *num_global_part );CHKERR( rval, "PComm::get_global_part_count failed" );
00521     RETURN( iBase_SUCCESS );
00522 }
00523
00524 void iMeshP_getNumLocalParts( iMesh_Instance instance,
00525                               const iMeshP_PartitionHandle partition_handle,
00526                               int* num_local_part,
00527                               int* err )
00528 {
00529     ParallelComm* pcomm = PCOMM;
00530     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
00531
00532     *num_local_part = pcomm->partition_sets().size();
00533     RETURN( iBase_SUCCESS );
00534 }
00535
00536 void iMeshP_getLocalParts( iMesh_Instance instance,
00537                            const iMeshP_PartitionHandle partition_handle,
00538                            iMeshP_PartHandle** part_handles,
00539                            int* part_handles_allocated,
00540                            int* part_handles_size,
00541                            int* err )
00542 {
00543     ParallelComm* pcomm = PCOMM;
00544     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
00545
00546     RANGE_TO_ITAPS_ARRAY( pcomm->partition_sets(), part_handles );
00547     RETURN( iBase_SUCCESS );
00548 }
00549
00550 void iMeshP_getRankOfPart( iMesh_Instance instance,
00551                            const iMeshP_PartitionHandle partition_handle,
00552                            const iMeshP_Part part_id,
00553                            int* rank,
00554                            int* err )
00555 {
00556     int junk1 = 1, junk2 = 1;
00557     iMeshP_getRankOfPartArr( instance, partition_handle, &part_id, 1, &rank, &junk1, &junk2, err );
00558 }
00559
00560 void iMeshP_getRankOfPartArr( iMesh_Instance instance,
00561                               const iMeshP_PartitionHandle partition_handle,
00562                               const iMeshP_Part* part_ids,
00563                               const int part_ids_size,
00564                               int** rank,
00565                               int* rank_allocated,
00566                               int* rank_size,
00567                               int* err )
00568 {
00569     ParallelComm* pcomm = PCOMM;
00570     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
00571
00572     ALLOC_CHECK_ARRAY( rank, part_ids_size );
00573     ErrorCode rval = MB_SUCCESS;
00574     for( int i = 0; i < part_ids_size; ++i )
00575     {
00576         rval = pcomm->get_part_owner( part_ids[i], ( *rank )[i] );CHKERR( rval, "PComm::get_part_owner failed" );
00577     }
00578     KEEP_ARRAY( rank );
00579     RETURN( iBase_SUCCESS );
00580 }
00581
00582 void iMeshP_getNumOfTypeAll( iMesh_Instance instance,
00583                              const iMeshP_PartitionHandle partition_handle,
00584                              const iBase_EntitySetHandle entity_set_handle,
00585                              const int entity_type,
00586                              int* num_type,
00587                              int* err )
00588 {
00589     ParallelComm* pcomm = PCOMM;
00590     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
00591
00592     Range entities;
00593     ErrorCode rval = get_entities( MOABI, itaps_cast< EntityHandle >( entity_set_handle ), entity_type,
00594                                    iMesh_ALL_TOPOLOGIES, entities );
00595     int count      = 0;
00596     if( MB_SUCCESS == rval ) rval = count_owned( pcomm, entities, count );
00597
00598     int vals[2] = { count, rval }, sums[2];
00599     int ierr    = MPI_Allreduce( vals, sums, 2, MPI_INT, MPI_SUM, pcomm->proc_config().proc_comm() );
00600     assert( iBase_SUCCESS == 0 );
00601     if( ierr || sums[1] ) RETURN( iBase_FAILURE );
00602
00603     *num_type = sums[0];
00604     RETURN( iBase_SUCCESS );
00605 }
00606
00607 void iMeshP_getNumOfTopoAll( iMesh_Instance instance,
00608                              const iMeshP_PartitionHandle partition_handle,
00609                              const iBase_EntitySetHandle entity_set_handle,
00610                              const int entity_topology,
00611                              int* num_topo,
00612                              int* err )
00613 {
00614     ParallelComm* pcomm = PCOMM;
00615     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
00616
00617     Range entities;
00618     ErrorCode rval = get_entities( MOABI, itaps_cast< EntityHandle >( entity_set_handle ), iBase_ALL_TYPES,
00619                                    entity_topology, entities );
00620     int count      = 0;
00621     if( MB_SUCCESS == rval ) rval = count_owned( pcomm, entities, count );
00622
00623     int vals[2] = { count, rval }, sums[2];
00624     int ierr    = MPI_Allreduce( vals, sums, 2, MPI_INT, MPI_SUM, pcomm->proc_config().proc_comm() );
00625     assert( iBase_SUCCESS == 0 );
00626     if( ierr || sums[1] ) RETURN( iBase_FAILURE );
00627
00628     *num_topo = sums[0];
00629     RETURN( iBase_SUCCESS );
00630 }
00631
00632 void iMeshP_createPart( iMesh_Instance instance,
00633                         iMeshP_PartitionHandle partition_handle,
00634                         iMeshP_PartHandle* part_handle,
00635                         int* err )
00636 {
00637     ParallelComm* pcomm = PCOMM;
00638     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
00639
00640     EntityHandle h;
00641     ErrorCode rval = pcomm->create_part( h );CHKERR( rval, "Part creation failed" );
00642     *part_handle = itaps_cast< iMeshP_PartHandle >( h );
00643     RETURN( iBase_SUCCESS );
00644 }
00645
00646 void iMeshP_destroyPart( iMesh_Instance instance,
00647                          iMeshP_PartitionHandle partition_handle,
00648                          iMeshP_PartHandle part_handle,
00649                          int* err )
00650 {
00651     ParallelComm* pcomm = PCOMM;
00652     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
00653
00654     ErrorCode rval = pcomm->destroy_part( itaps_cast< EntityHandle >( part_handle ) );CHKERR( rval, "Part destruction failed" );
00655     RETURN( iBase_SUCCESS );
00656 }
00657
00658 void iMeshP_getNumPartNbors( iMesh_Instance instance,
00659                              iMeshP_PartitionHandle partition_handle,
00660                              iMeshP_PartHandle part_handle,
00661                              int entity_type,
00662                              int* num_part_nbors,
00663                              int* err )
00664 {
00665     int junk1 = 1, junk2 = 1;
00666     iMeshP_getNumPartNborsArr( instance, partition_handle, &part_handle, 1, entity_type, &num_part_nbors, &junk1,
00667                                &junk2, err );
00668 }
00669
00670 void iMeshP_getNumPartNborsArr( iMesh_Instance instance,
00671                                 const iMeshP_PartitionHandle partition_handle,
00672                                 const iMeshP_PartHandle* part_handles,
00673                                 const int part_handles_size,
00674                                 int /*entity_type*/,
00675                                 int** num_part_nbors,
00676                                 int* num_part_nbors_allocated,
00677                                 int* num_part_nbors_size,
00678                                 int* err )
00679 {
00680     ParallelComm* pcomm = PCOMM;
00681     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
00682
00683     ALLOC_CHECK_ARRAY( num_part_nbors, part_handles_size );
00684
00685     int n, neighbors[MAX_SHARING_PROCS];
00686     ErrorCode rval;
00687     for( int i = 0; i < part_handles_size; ++i )
00688     {
00689         EntityHandle h = itaps_cast< EntityHandle >( part_handles[i] );
00690         rval           = pcomm->get_part_neighbor_ids( h, neighbors, n );CHKERR( rval, "error getting neighbor ids" );
00691         ( *num_part_nbors )[i] = n;
00692     }
00693
00694     KEEP_ARRAY( num_part_nbors );
00695     RETURN( iBase_SUCCESS );
00696 }
00697
00698 void iMeshP_getPartNbors( iMesh_Instance instance,
00699                           const iMeshP_PartitionHandle partition_handle,
00700                           const iMeshP_PartHandle part_handle,
00701                           int entity_type,
00702                           int* num_part_nbors,
00703                           iMeshP_Part** nbor_part_ids,
00704                           int* nbor_part_ids_allocated,
00705                           int* nbor_part_ids_size,
00706                           int* err )
00707 {
00708     int junk1 = 1, junk2 = 1;
00709     iMeshP_getPartNborsArr( instance, partition_handle, &part_handle, 1, entity_type, &num_part_nbors, &junk1, &junk2,
00710                             nbor_part_ids, nbor_part_ids_allocated, nbor_part_ids_size, err );
00711 }
00712
00713 void iMeshP_getPartNborsArr( iMesh_Instance instance,
00714                              const iMeshP_PartitionHandle partition_handle,
00715                              const iMeshP_PartHandle* part_handles,
00716                              const int part_handles_size,
00717                              int /*entity_type*/,
00718                              int** num_part_nbors,
00719                              int* num_part_nbors_allocated,
00720                              int* num_part_nbors_size,
00721                              iMeshP_Part** nbor_part_ids,
00722                              int* nbor_part_ids_allocated,
00723                              int* nbor_part_ids_size,
00724                              int* err )
00725 {
00726     ParallelComm* pcomm = PCOMM;
00727     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
00728
00729     ALLOC_CHECK_ARRAY( num_part_nbors, part_handles_size );
00730
00731     std::vector< int > all_neighbors;
00732     int n, pnbor[MAX_SHARING_PROCS];
00733     ErrorCode rval;
00734     for( int i = 0; i < part_handles_size; ++i )
00735     {
00736         EntityHandle h = itaps_cast< EntityHandle >( part_handles[i] );
00737         rval           = pcomm->get_part_neighbor_ids( h, pnbor, n );CHKERR( rval, "error getting neighbor ids" );
00738         ( *num_part_nbors )[i] = n;
00739         std::copy( pnbor, pnbor + n, std::back_inserter( all_neighbors ) );
00740     }
00741
00742     ALLOC_CHECK_ARRAY_NOFAIL( nbor_part_ids, all_neighbors.size() );
00743     memcpy( *nbor_part_ids, &all_neighbors[0], sizeof( int ) * all_neighbors.size() );
00744
00745     KEEP_ARRAY( num_part_nbors );
00746     RETURN( iBase_SUCCESS );
00747 }
00748
00749 void iMeshP_getNumPartBdryEnts( iMesh_Instance instance,
00750                                 const iMeshP_PartitionHandle partition_handle,
00751                                 const iMeshP_PartHandle part_handle,
00752                                 const int entity_type,
00753                                 const int entity_topology,
00754                                 const iMeshP_Part target_part_id,
00755                                 int* num_entities,
00756                                 int* err )
00757 {
00758     Range entities;
00759     ErrorCode rval = get_boundary_entities( PCOMM, itaps_cast< EntityHandle >( part_handle ), entity_type,
00760                                             entity_topology, target_part_id, entities );CHKERR( rval, "failed to get boundary entities" );
00761     *num_entities = entities.size();
00762     RETURN( iBase_SUCCESS );
00763 }
00764
00765 void iMeshP_getPartBdryEnts( iMesh_Instance instance,
00766                              const iMeshP_PartitionHandle partition_handle,
00767                              const iMeshP_PartHandle part_handle,
00768                              const int entity_type,
00769                              const int entity_topology,
00770                              const iMeshP_Part target_part_id,
00771                              iBase_EntityHandle** entity_handles,
00772                              int* entity_handles_allocated,
00773                              int* entity_handles_size,
00774                              int* err )
00775 {
00776     Range entities;
00777     ErrorCode rval = get_boundary_entities( PCOMM, itaps_cast< EntityHandle >( part_handle ), entity_type,
00778                                             entity_topology, target_part_id, entities );CHKERR( rval, "failed to get boundary entities" );
00779     RANGE_TO_ITAPS_ARRAY( entities, entity_handles );
00780     RETURN( iBase_SUCCESS );
00781 }
00782
00783 void iMeshP_initPartBdryEntIter( iMesh_Instance instance,
00784                                  const iMeshP_PartitionHandle partition_handle,
00785                                  const iMeshP_PartHandle part_handle,
00786                                  const int entity_type,
00787                                  const int entity_topology,
00788                                  const iMeshP_Part nbor_part_id,
00789                                  iBase_EntityIterator* entity_iterator,
00790                                  int* err )
00791 {
00792     iMeshP_initPartBdryEntArrIter( instance, partition_handle, part_handle, entity_type, entity_topology, 1,
00793                                    nbor_part_id, reinterpret_cast< iBase_EntityArrIterator* >( entity_iterator ), err );
00794 }
00795
00796 void iMeshP_initPartBdryEntArrIter( iMesh_Instance instance,
00797                                     const iMeshP_PartitionHandle partition_handle,
00798                                     const iMeshP_PartHandle part_handle,
00799                                     const int entity_type,
00800                                     const int entity_topology,
00801                                     const int array_size,
00802                                     const iMeshP_Part nbor_part_id,
00803                                     iBase_EntityArrIterator* entity_iterator,
00804                                     int* err )
00805 {
00806     *entity_iterator =
00807         new PartBoundaryIter( PCOMM, itaps_cast< EntityHandle >( part_handle ), (iBase_EntityType)entity_type,
00808                               (iMesh_EntityTopology)entity_topology, nbor_part_id, array_size );
00809     ErrorCode result = ( *entity_iterator )->reset( MOABI );
00810     if( MB_SUCCESS != result ) delete *entity_iterator;CHKERR( result, "iMesh_initEntArrIter: ERROR getting entities of proper type or topology." );
00811     RETURN( iBase_SUCCESS );
00812 }
00813
00814 void iMeshP_getNumOfType( iMesh_Instance instance,
00815                           const iMeshP_PartitionHandle,
00816                           const iMeshP_PartHandle part_handle,
00817                           const iBase_EntitySetHandle entity_set_handle,
00818                           const int entity_type,
00819                           int* num_type,
00820                           int* err )
00821 {
00822     Range r;
00823     set_intersection_query( instance, part_handle, entity_set_handle, entity_type, iMesh_ALL_TOPOLOGIES, r, err );
00824     *num_type = r.size();
00825 }
00826
00827 void iMeshP_getNumOfTopo( iMesh_Instance instance,
00828                           const iMeshP_PartitionHandle /*partition_handle*/,
00829                           const iMeshP_PartHandle part_handle,
00830                           const iBase_EntitySetHandle entity_set_handle,
00831                           const int entity_topology,
00832                           int* num_topo,
00833                           int* err )
00834 {
00835     Range r;
00836     set_intersection_query( instance, part_handle, entity_set_handle, iBase_ALL_TYPES, entity_topology, r, err );
00837     *num_topo = r.size();
00838 }
00839
00840 void iMeshP_getAdjEntIndices( iMesh_Instance instance,
00841                               iMeshP_PartitionHandle partition,
00842                               iMeshP_PartHandle part,
00843                               iBase_EntitySetHandle entity_set_handle,
00844                               int entity_type_requestor,
00845                               int entity_topology_requestor,
00846                               int entity_type_requested,
00847                               iBase_EntityHandle** entity_handles,
00848                               int* entity_handles_allocated,
00849                               int* entity_handles_size,
00850                               iBase_EntityHandle** adj_entity_handles,
00851                               int* adj_entity_handles_allocated,
00852                               int* adj_entity_handles_size,
00853                               int** adj_entity_indices,
00854                               int* adj_entity_indices_allocated,
00855                               int* adj_entity_indices_size,
00856                               int** offset,
00857                               int* offset_allocated,
00858                               int* offset_size,
00859                               int* err )
00860 {
00861     const int allocated_entity_handles = ( *entity_handles_allocated == 0 );
00862     const int allocated_indices        = ( *adj_entity_indices_allocated == 0 );
00863     const int allocated_offset         = ( *offset_allocated == 0 );
00864
00865     // get source entities
00866     iMeshP_getEntities( instance, partition, part, entity_set_handle, entity_type_requestor, entity_topology_requestor,
00867                         entity_handles, entity_handles_allocated, entity_handles_size, err );
00868     if( iBase_SUCCESS != *err ) return;
00869
00870     // get adjacencies
00871     iBase_EntityHandle* all_adj_handles = 0;
00872     int size = 0, alloc = 0;
00873     iMesh_getEntArrAdj( instance, *entity_handles, *entity_handles_size, entity_type_requested, &all_adj_handles,
00874                         &alloc, &size, offset, offset_allocated, offset_size, err );
00875     if( *err != iBase_SUCCESS )
00876     {
00877         if( allocated_entity_handles )
00878         {
00879             free( *entity_handles );
00880             *entity_handles           = 0;
00881             *entity_handles_allocated = 0;
00882         }
00883         return;
00884     }
00885
00886     // allocate or check size of adj_entity_indices
00887     *adj_entity_indices_size = size;
00888     if( allocated_indices )
00889     {
00890         *adj_entity_indices = (int*)malloc( sizeof( iBase_EntityHandle ) * size );
00891         if( !*adj_entity_indices )
00892             *err = iBase_MEMORY_ALLOCATION_FAILED;
00893         else
00894             *adj_entity_indices_allocated = size;
00895     }
00896     else if( *adj_entity_indices_allocated < size )
00897     {
00898         *err = iBase_BAD_ARRAY_DIMENSION;
00899     }
00900     if( iBase_SUCCESS != *err )
00901     {
00902         free( all_adj_handles );
00903         if( allocated_entity_handles )
00904         {
00905             free( *entity_handles );
00906             *entity_handles           = 0;
00907             *entity_handles_allocated = 0;
00908         }
00909         if( allocated_offset )
00910         {
00911             free( *offset );
00912             *offset           = 0;
00913             *offset_allocated = 0;
00914         }
00915         return;
00916     }
00917
00918     // Now create an array of unique sorted handles from all_adj_handles.
00919     // We need to create a copy because we still need all_adj_handles.  We
00920     // will eventually need to copy the resulting unique list into
00921     // adj_entity_handles, so if adj_entity_handles is already allocated and
00922     // of sufficient size, use it rather than allocating another temporary.
00923     iBase_EntityHandle* unique_adj = 0;
00924     if( *adj_entity_handles_allocated >= size )
00925     {
00926         unique_adj = *adj_entity_handles;
00927     }
00928     else
00929     {
00930         unique_adj = (iBase_EntityHandle*)malloc( sizeof( iBase_EntityHandle ) * size );
00931     }
00932     std::copy( all_adj_handles, all_adj_handles + size, unique_adj );
00933     std::sort( unique_adj, unique_adj + size );
00934     *adj_entity_handles_size = std::unique( unique_adj, unique_adj + size ) - unique_adj;
00935
00936     // If we created a temporary array for unique_adj rather than using
00937     // already allocated space in adj_entity_handles, allocate adj_entity_handles
00938     // and copy the unique handle list into it
00939     if( *adj_entity_handles != unique_adj )
00940     {
00941         if( !*adj_entity_handles_allocated )
00942         {
00943             *adj_entity_handles =
00944                 (iBase_EntityHandle*)malloc( sizeof( iBase_EntityHandle ) * *adj_entity_handles_size );
00945             if( !*adj_entity_handles )
00946                 *err = iBase_MEMORY_ALLOCATION_FAILED;
00947             else
00948                 *adj_entity_handles_allocated = *adj_entity_handles_size;
00949         }
00950         else if( *adj_entity_handles_allocated < *adj_entity_handles_size )
00951             *err = iBase_BAD_ARRAY_DIMENSION;
00952         if( iBase_SUCCESS != *err )
00953         {
00954             free( unique_adj );
00955             free( all_adj_handles );
00956             if( allocated_entity_handles )
00957             {
00958                 free( *entity_handles );
00959                 *entity_handles           = 0;
00960                 *entity_handles_allocated = 0;
00961             }
00962             if( allocated_offset )
00963             {
00964                 free( *offset );
00965                 *offset           = 0;
00966                 *offset_allocated = 0;
00967             }
00968             if( allocated_indices )
00969             {
00970                 free( *adj_entity_indices );
00971                 *adj_entity_indices           = 0;
00972                 *adj_entity_indices_allocated = 0;
00973             }
00974             return;
00975         }
00976
00977         std::copy( unique_adj, unique_adj + *adj_entity_handles_size, *adj_entity_handles );
00978         free( unique_adj );
00979         unique_adj = *adj_entity_handles;
00980     }
00981
00982     // convert from adjacency list to indices into unique_adj
00983     for( int i = 0; i < *adj_entity_indices_size; ++i )
00984         ( *adj_entity_indices )[i] =
00985             std::lower_bound( unique_adj, unique_adj + *adj_entity_handles_size, all_adj_handles[i] ) - unique_adj;
00986     free( all_adj_handles );
00987 }
00988
00989 void iMeshP_getEntities( iMesh_Instance instance,
00990                          const iMeshP_PartitionHandle,
00991                          const iMeshP_PartHandle part_handle,
00992                          const iBase_EntitySetHandle entity_set_handle,
00993                          const int entity_type,
00994                          const int entity_topology,
00995                          iBase_EntityHandle** entity_handles,
00996                          int* entity_handles_allocated,
00997                          int* entity_handles_size,
00998                          int* err )
00999 {
01000     Range r;
01001     set_intersection_query( instance, part_handle, entity_set_handle, entity_type, entity_topology, r, err );
01002     if( iBase_SUCCESS != *err ) return;
01003
01004     RANGE_TO_ITAPS_ARRAY( r, entity_handles );
01005     RETURN( iBase_SUCCESS );
01006 }
01007
01008 void iMeshP_getAdjEntities( iMesh_Instance instance,
01009                             const iMeshP_PartitionHandle /*partition_handle*/,
01010                             const iMeshP_PartHandle part_handle,
01011                             const iBase_EntitySetHandle entity_set_handle,
01012                             const int entity_type_requestor,
01013                             const int entity_topology_requestor,
01014                             const int entity_type_requested,
01015                             iBase_EntityHandle** adj_entity_handles,
01016                             int* adj_entity_handles_allocated,
01017                             int* adj_entity_handles_size,
01018                             int** offset,
01019                             int* offset_allocated,
01020                             int* offset_size,
01021                             int** in_entity_set,
01022                             int* in_entity_set_allocated,
01023                             int* in_entity_set_size,
01024                             int* err )
01025 {
01026     ErrorCode rval;
01027     Range r;
01028     set_intersection_query( instance, part_handle, entity_set_handle, entity_type_requestor, entity_topology_requestor,
01029                             r, err );
01030     if( iBase_SUCCESS != *err ) return;
01031
01032     // count adjacencies
01033     std::vector< EntityHandle > tmp_storage;
01034     int num_adj = 0;
01035     int num_conn;
01036     const EntityHandle* conn_ptr;
01037     for( Range::iterator i = r.begin(); i != r.end(); ++i )
01038     {
01039         if( entity_type_requested || TYPE_FROM_HANDLE( *i ) == MBPOLYHEDRON )
01040         {
01041             tmp_storage.clear();
01042             rval = MOABI->get_adjacencies( &*i, 1, entity_type_requested, false, tmp_storage );CHKERR( rval, "get_adjacencies failed" );
01043             num_adj += tmp_storage.size();
01044         }
01045         else
01046         {
01047             rval = MOABI->get_connectivity( *i, conn_ptr, num_conn, false, &tmp_storage );CHKERR( rval, "get_connectivity failed" );
01048             num_adj += num_conn;
01049         }
01050     }
01051
01052     // get adjacencies
01053     ALLOC_CHECK_ARRAY( adj_entity_handles, num_adj );
01054     ALLOC_CHECK_ARRAY( offset, r.size() );
01055     int arr_pos      = 0;
01056     int* offset_iter = *offset;
01057     for( Range::iterator i = r.begin(); i != r.end(); ++i )
01058     {
01059         *offset_iter = arr_pos;
01060         ++offset_iter;
01061
01062         tmp_storage.clear();
01063         rval = MOABI->get_adjacencies( &*i, 1, entity_type_requested, false, tmp_storage );CHKERR( rval, "get_adjacencies failed" );
01064         for( std::vector< EntityHandle >::iterator j = tmp_storage.begin(); j != tmp_storage.end(); ++j )
01065         {
01066             ( *adj_entity_handles )[arr_pos] = itaps_cast< iBase_EntityHandle >( *j );
01067             ++arr_pos;
01068         }
01069     }
01070
01071     // get in_entity_set
01072     iMesh_isEntArrContained( instance, entity_set_handle, *adj_entity_handles, *adj_entity_handles_size, in_entity_set,
01073                              in_entity_set_allocated, in_entity_set_size, err );
01074
01075     if( iBase_SUCCESS == *err )
01076     {
01077         KEEP_ARRAY( adj_entity_handles );
01078         KEEP_ARRAY( offset );
01079     }
01080 }
01081
01082 void iMeshP_initEntIter( iMesh_Instance instance,
01083                          const iMeshP_PartitionHandle partition_handle,
01084                          const iMeshP_PartHandle part_handle,
01085                          const iBase_EntitySetHandle entity_set_handle,
01086                          const int requested_entity_type,
01087                          const int requested_entity_topology,
01088                          iBase_EntityIterator* entity_iterator,
01089                          int* err )
01090 {
01091     iMeshP_initEntArrIter( instance, partition_handle, part_handle, entity_set_handle, requested_entity_type,
01092                            requested_entity_topology, 1,
01093                            reinterpret_cast< iBase_EntityArrIterator* >( entity_iterator ), err );
01094 }
01095
01096 void iMeshP_initEntArrIter( iMesh_Instance instance,
01097                             const iMeshP_PartitionHandle /*partition_handle*/,
01098                             const iMeshP_PartHandle part_handle,
01099                             const iBase_EntitySetHandle entity_set_handle,
01100                             const int requested_entity_type,
01101                             const int requested_entity_topology,
01102                             const int requested_array_size,
01103                             iBase_EntityArrIterator* entArr_iterator,
01104                             int* err )
01105 {
01106     if( !entity_set_handle || entity_set_handle == part_handle )
01107     {
01108         iMesh_initEntArrIter( instance, part_handle, requested_entity_type, requested_entity_topology,
01109                               requested_array_size,
01110                               0,  // TODO: update this function for "resilient" arg
01111                               entArr_iterator, err );
01112     }
01113     else
01114     {
01115         unsigned flags;
01116         ErrorCode result = MOABI->get_meshset_options( itaps_cast< EntityHandle >( entity_set_handle ), flags );CHKERR( result, "Invalid entity set handle" );
01117         if( flags & MESHSET_ORDERED )
01118             *entArr_iterator = new SetIntersectIter< std::vector< EntityHandle > >(
01119                 (iBase_EntityType)requested_entity_type, (iMesh_EntityTopology)requested_entity_topology,
01120                 itaps_cast< EntityHandle >( entity_set_handle ), itaps_cast< EntityHandle >( part_handle ),
01121                 requested_array_size );
01122         else
01123             *entArr_iterator =
01124                 new SetIntersectIter< Range >( (iBase_EntityType)requested_entity_type,
01125                                                (iMesh_EntityTopology)requested_entity_topology,
01126                                                itaps_cast< EntityHandle >( entity_set_handle ),
01127                                                itaps_cast< EntityHandle >( part_handle ), requested_array_size );
01128         result = ( *entArr_iterator )->reset( MOABI );
01129         if( MB_SUCCESS != result ) delete *entArr_iterator;CHKERR( result, "iMesh_initEntArrIter: ERROR getting entities of proper type or topology." );
01130         RETURN( iBase_SUCCESS );
01131     }
01132 }
01133
01134 void iMeshP_getEntOwnerPart( iMesh_Instance instance,
01135                              const iMeshP_PartitionHandle partition_handle,
01136                              const iBase_EntityHandle entity_handle,
01137                              iMeshP_Part* part_id,
01138                              int* err )
01139 {
01140     int junk1 = 1, junk2 = 1;
01141     iMeshP_getEntOwnerPartArr( instance, partition_handle, &entity_handle, 1, &part_id, &junk1, &junk2, err );
01142 }
01143
01144 void iMeshP_getEntOwnerPartArr( iMesh_Instance instance,
01145                                 const iMeshP_PartitionHandle partition_handle,
01146                                 const iBase_EntityHandle* entity_handles,
01147                                 const int entity_handles_size,
01148                                 iMeshP_Part** part_ids,
01149                                 int* part_ids_allocated,
01150                                 int* part_ids_size,
01151                                 int* err )
01152 {
01153     ParallelComm* pcomm = PCOMM;
01154     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
01155
01156     int id;
01157     ALLOC_CHECK_ARRAY( part_ids, entity_handles_size );
01158     ErrorCode rval = MB_SUCCESS;
01159     for( int i = 0; i < entity_handles_size; ++i )
01160     {
01161         EntityHandle h   = itaps_cast< EntityHandle >( entity_handles[i] );
01162         rval             = pcomm->get_owning_part( h, id );
01163         ( *part_ids )[i] = id;CHKERR( rval, "Failet get part owner" );
01164     }
01165     KEEP_ARRAY( part_ids );
01166     RETURN( iBase_SUCCESS );
01167 }
01168
01169 void iMeshP_isEntOwner( iMesh_Instance instance,
01170                         const iMeshP_PartitionHandle partition_handle,
01171                         const iMeshP_PartHandle part_handle,
01172                         const iBase_EntityHandle entity_handle,
01173                         int* is_owner,
01174                         int* err )
01175 {
01176     int junk1 = 1, junk2 = 1;
01177     iMeshP_isEntOwnerArr( instance, partition_handle, part_handle, &entity_handle, 1, &is_owner, &junk1, &junk2, err );
01178 }
01179
01180 void iMeshP_isEntOwnerArr( iMesh_Instance instance,
01181                            const iMeshP_PartitionHandle partition_handle,
01182                            const iMeshP_PartHandle part_handle,
01183                            const iBase_EntityHandle* entity_handles,
01184                            const int entity_handles_size,
01185                            int** is_owner,
01186                            int* is_owner_allocated,
01187                            int* is_owner_size,
01188                            int* err )
01189 {
01190     ErrorCode rval;
01191     ParallelComm* pcomm = PCOMM;
01192     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
01193
01194     int id;
01195     rval = pcomm->get_part_id( itaps_cast< EntityHandle >( part_handle ), id );CHKERR( rval, "error getting part id" );
01196
01197     ALLOC_CHECK_ARRAY( is_owner, entity_handles_size );
01198     *is_owner_size = entity_handles_size;
01199
01200     int owner;
01201     for( int i = 0; i < entity_handles_size; ++i )
01202     {
01203         rval = pcomm->get_owner( itaps_cast< EntityHandle >( entity_handles[i] ), owner );CHKERR( rval, "error getting owner" );
01204         ( *is_owner )[i] = ( owner == id );
01205     }
01206
01207     KEEP_ARRAY( is_owner );
01208     RETURN( iBase_SUCCESS );
01209 }
01210
01211 void iMeshP_getEntStatus( iMesh_Instance instance,
01212                           /*in*/ const iMeshP_PartitionHandle partition_handle,
01213                           /*in*/ const iMeshP_PartHandle part_handle,
01214                           /*in*/ const iBase_EntityHandle entity_handle,
01215                           /*out*/ int* par_status,  // Values=INTERNAL,BOUNDARY,GHOST
01216                           int* err )
01217 {
01218     int junk1 = 1, junk2 = 1;
01219     iMeshP_getEntStatusArr( instance, partition_handle, part_handle, &entity_handle, 1, &par_status, &junk1, &junk2,
01220                             err );
01221 }
01222
01223 void iMeshP_getEntStatusArr( iMesh_Instance instance,
01224                              /*in*/ const iMeshP_PartitionHandle partition_handle,
01225                              /*in*/ const iMeshP_PartHandle /*part_handle*/,
01226                              /*in*/ const iBase_EntityHandle* entity_handles,
01227                              /*in*/ const int entity_handles_size,
01228                              /*inout*/ int** par_status,  // Values=INTERNAL,BOUNDARY,GHOST
01229                              /*inout*/ int* par_status_allocated,
01230                              /*inout*/ int* par_status_size,
01231                              int* err )
01232 {
01233     ParallelComm* pcomm = PCOMM;
01234     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
01235
01236     std::vector< unsigned char > pstatus( entity_handles_size );
01237     ErrorCode result = MOABI->tag_get_data( pcomm->pstatus_tag(), itaps_cast< const EntityHandle* >( entity_handles ),
01238                                             entity_handles_size, &pstatus[0] );CHKERR( result, "error getting pstatus_tag" );
01239
01240     ALLOC_CHECK_ARRAY( par_status, entity_handles_size );
01241     for( int i = 0; i < entity_handles_size; i++ )
01242     {
01243         if( !pstatus[i] )
01244             ( *par_status )[i] = iMeshP_INTERNAL;
01245         else if( pstatus[i] & PSTATUS_GHOST )
01246             ( *par_status )[i] = iMeshP_GHOST;
01247         else if( pstatus[i] & PSTATUS_INTERFACE )
01248             ( *par_status )[i] = iMeshP_BOUNDARY;
01249     }
01250
01251     KEEP_ARRAY( par_status );
01252     RETURN( iBase_SUCCESS );
01253 }
01254
01255 void iMeshP_getNumCopies( iMesh_Instance instance,
01256                           const iMeshP_PartitionHandle partition_handle,
01257                           const iBase_EntityHandle entity_handle,
01258                           int* num_copies_ent,
01259                           int* err )
01260 {
01261     ParallelComm* pcomm = PCOMM;
01262     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
01263
01264     int ids[MAX_SHARING_PROCS];
01265     ErrorCode rval = pcomm->get_sharing_parts( itaps_cast< EntityHandle >( entity_handle ), ids, *num_copies_ent );CHKERR( rval, "ParallelComm::get_sharing_parts failed" );
01266     RETURN( iBase_SUCCESS );
01267 }
01268
01269 void iMeshP_getCopyParts( iMesh_Instance instance,
01270                           const iMeshP_PartitionHandle partition_handle,
01271                           const iBase_EntityHandle entity_handle,
01272                           iMeshP_Part** part_ids,
01273                           int* part_ids_allocated,
01274                           int* part_ids_size,
01275                           int* err )
01276 {
01277     ParallelComm* pcomm = PCOMM;
01278     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
01279
01280     int ids[MAX_SHARING_PROCS], num_ids;
01281     ErrorCode rval = pcomm->get_sharing_parts( itaps_cast< EntityHandle >( entity_handle ), ids, num_ids );CHKERR( rval, "ParallelComm::get_sharing_parts failed" );
01282     ALLOC_CHECK_ARRAY_NOFAIL( part_ids, num_ids );
01283     std::copy( ids, ids + num_ids, *part_ids );
01284     RETURN( iBase_SUCCESS );
01285 }
01286
01287 void iMeshP_getCopies( iMesh_Instance instance,
01288                        const iMeshP_PartitionHandle partition_handle,
01289                        const iBase_EntityHandle entity_handle,
01290                        iMeshP_Part** part_ids,
01291                        int* part_ids_allocated,
01292                        int* part_ids_size,
01293                        iBase_EntityHandle** copies_entity_handles,
01294                        int* copies_entity_handles_allocated,
01295                        int* copies_entity_handles_size,
01296                        int* err )
01297 {
01298     ParallelComm* pcomm = PCOMM;
01299     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
01300
01301     int ids[MAX_SHARING_PROCS], num_ids;
01302     EntityHandle handles[MAX_SHARING_PROCS];
01303     ErrorCode rval = pcomm->get_sharing_parts( itaps_cast< EntityHandle >( entity_handle ), ids, num_ids, handles );CHKERR( rval, "ParallelComm::get_sharing_parts failed" );
01304     ALLOC_CHECK_ARRAY_NOFAIL( part_ids, num_ids );
01305     ALLOC_CHECK_ARRAY_NOFAIL( copies_entity_handles, num_ids );
01306     for( int i = 0; i < num_ids; ++i )
01307     {
01308         ( *part_ids )[i]              = ids[i];
01309         ( *copies_entity_handles )[i] = itaps_cast< iBase_EntityHandle >( handles[i] );
01310     }
01311     RETURN( iBase_SUCCESS );
01312 }
01313
01314 void iMeshP_getCopyOnPart( iMesh_Instance instance,
01315                            const iMeshP_PartitionHandle partition_handle,
01316                            const iBase_EntityHandle entity_handle,
01317                            const iMeshP_Part part_id,
01318                            iBase_EntityHandle* copy_entity_handle,
01319                            int* err )
01320 {
01321     ParallelComm* pcomm = PCOMM;
01322     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
01323
01324     int ids[MAX_SHARING_PROCS], num_ids;
01325     EntityHandle handles[MAX_SHARING_PROCS];
01326     ErrorCode rval = pcomm->get_sharing_parts( itaps_cast< EntityHandle >( entity_handle ), ids, num_ids, handles );CHKERR( rval, "ParallelComm::get_sharing_parts failed" );
01327     int idx = std::find( ids, ids + num_ids, part_id ) - ids;
01328     if( idx == num_ids ) RETURN( iBase_FAILURE );
01329
01330     *copy_entity_handle = itaps_cast< iBase_EntityHandle >( handles[idx] );
01331     RETURN( iBase_SUCCESS );
01332 }
01333
01334 void iMeshP_getOwnerCopy( iMesh_Instance instance,
01335                           const iMeshP_PartitionHandle partition_handle,
01336                           const iBase_EntityHandle entity_handle,
01337                           iMeshP_Part* owner_part_id,
01338                           iBase_EntityHandle* owner_entity_handle,
01339                           int* err )
01340 {
01341     ParallelComm* pcomm = PCOMM;
01342     if( !pcomm ) ERROR( iBase_FAILURE, "No PComm" );
01343
01344     int id;
01345     EntityHandle h;
01346     ErrorCode rval = pcomm->get_owning_part( itaps_cast< EntityHandle >( entity_handle ), id, &h );CHKERR( rval, "Failed to get owner" );
01347     *owner_part_id       = id;
01348     *owner_entity_handle = itaps_cast< iBase_EntityHandle >( h );
01349     RETURN( iBase_SUCCESS );
01350 }
01351
01352 void iMeshP_waitForAnyRequest( iMesh_Instance instance,
01353                                iMeshP_PartitionHandle,
01354                                iMeshP_RequestHandle*,
01355                                int,
01356                                int*,
01357                                int* err )
01358 {
01359     FIXME;
01360     RETURN( iBase_NOT_SUPPORTED );
01361 }
01362
01363 void iMeshP_waitForAllRequests( iMesh_Instance instance, iMeshP_PartitionHandle, iMeshP_RequestHandle*, int, int* err )
01364 {
01365     FIXME;
01366     RETURN( iBase_NOT_SUPPORTED );
01367 }
01368
01369 void iMeshP_waitForRequestEnt( iMesh_Instance instance,
01370                                const iMeshP_PartitionHandle,
01371                                iMeshP_RequestHandle,
01372                                iBase_EntityHandle**,
01373                                int*,
01374                                int*,
01375                                int* err )
01376 {
01377     FIXME;
01378     RETURN( iBase_NOT_SUPPORTED );
01379 }
01380
01381 void iMeshP_testRequest( iMesh_Instance instance, const iMeshP_PartitionHandle, iMeshP_RequestHandle, int*, int* err )
01382 {
01383     FIXME;
01384     RETURN( iBase_NOT_SUPPORTED );
01385 }
01386
01387 void iMeshP_pollForRequests( iMesh_Instance instance,
01388                              iMeshP_PartitionHandle,
01389                              iMeshP_RequestHandle**,
01390                              int*,
01391                              int*,
01392                              int* err )
01393 {
01394     FIXME;
01395     RETURN( iBase_NOT_SUPPORTED );
01396 }
01397
01398 void iMeshP_exchEntArrToPartsAll( iMesh_Instance instance,
01399                                   const iMeshP_PartitionHandle partition_handle,
01400                                   const iBase_EntityHandle* entity_handles,
01401                                   const int entity_handles_size,
01402                                   const iMeshP_Part* target_part_ids,
01403                                   int command_code,
01404                                   int update_ghost,
01405                                   iMeshP_RequestHandle* /*request*/,
01406                                   int* err )
01407 {
01408     if( command_code == 1 )
01409     {
01410         std::cerr << "Entity migration option is not supported." << std::endl;
01411         RETURN( iBase_NOT_SUPPORTED );
01412     }
01413
01414     if( update_ghost == 1 )
01415     {
01416         std::cerr << "Gost update option is not supported." << std::endl;
01417         RETURN( iBase_NOT_SUPPORTED );
01418     }
01419
01420     // make exchange entity and processor list
01421     ErrorCode rval;
01422     ParallelComm* pcomm = PCOMM;
01423     std::vector< unsigned int > exchange_procs;
01424     std::vector< Range* > exchange_ents;
01425
01426     for( int i = 0; i < entity_handles_size; i++ )
01427     {
01428         int ind = -1;
01429         // iMeshP_Part target_p = target_part_ids[i];
01430         int target_p;
01431         rval = pcomm->get_part_owner( target_part_ids[i], target_p );CHKERR( rval, "ParallelComm::get_part_owner failed" );
01432
01433         std::vector< unsigned int >::iterator vit = std::find( exchange_procs.begin(), exchange_procs.end(), target_p );
01434         if( vit == exchange_procs.end() )
01435         {
01436             ind = exchange_procs.size();
01437             exchange_procs.push_back( target_p );
01438             exchange_ents.push_back( new Range );
01439         }
01440         else
01441             ind = vit - exchange_procs.begin();
01442
01443         exchange_ents[ind]->insert( itaps_cast< EntityHandle >( entity_handles[i] ) );
01444     }
01445
01446     std::vector< MPI_Request > recv_ent_reqs, recv_remoteh_reqs;
01447     rval = pcomm->exchange_owned_meshs( exchange_procs, exchange_ents, recv_ent_reqs, recv_remoteh_reqs, true );CHKERR( rval, "ParallelComm::exchange_owned_meshs failed" );
01448
01449     // delete exchange list
01450     std::vector< Range* >::iterator vit;
01451     for( vit = exchange_ents.begin(); vit != exchange_ents.end(); ++vit )
01452         delete( *vit );
01453
01454     RETURN( iBase_SUCCESS );
01455 }
01456
01457 void iMeshP_migrateEntity( iMesh_Instance instance,
01458                            const iMeshP_PartitionHandle,
01459                            const iMeshP_PartHandle,
01460                            const iBase_EntityHandle,
01461                            iMeshP_RequestHandle*,
01462                            int* err )
01463 {
01464     FIXME;
01465     RETURN( iBase_NOT_SUPPORTED );
01466 }
01467
01468 void iMeshP_updateVtxCoords( iMesh_Instance instance, const iMeshP_PartitionHandle, const iBase_EntityHandle, int* err )
01469 {
01470     FIXME;
01471     RETURN( iBase_NOT_SUPPORTED );
01472 }
01473
01474 void iMeshP_replaceOnPartBdry( iMesh_Instance instance,
01475                                const iMeshP_PartitionHandle,
01476                                const iBase_EntityHandle*,
01477                                const int,
01478                                const iBase_EntityHandle*,
01479                                const int,
01480                                const int*,
01481                                const int,
01482                                int* err )
01483 {
01484     FIXME;
01485     RETURN( iBase_NOT_SUPPORTED );
01486 }
01487
01488 void iMeshP_addGhostOf( iMesh_Instance instance,
01489                         const iMeshP_PartitionHandle,
01490                         const iMeshP_Part,
01491                         const iBase_EntityHandle,
01492                         iMeshP_RequestHandle*,
01493                         int* err )
01494 {
01495     FIXME;
01496     RETURN( iBase_NOT_SUPPORTED );
01497 }
01498
01499 void iMeshP_rmvGhostOf( iMesh_Instance instance,
01500                         const iMeshP_PartitionHandle,
01501                         const iMeshP_Part,
01502                         const iBase_EntityHandle,
01503                         int* err )
01504 {
01505     FIXME;
01506     RETURN( iBase_NOT_SUPPORTED );
01507 }
01508
01509 void iMeshP_syncMeshAll( iMesh_Instance instance, const iMeshP_PartitionHandle partition_handle, int* err )
01510 {
01511     ParallelComm* pcomm = PCOMM;
01512     ErrorCode rval      = pcomm->resolve_shared_ents( itaps_cast< EntityHandle >( partition_handle ), -1, -1 );CHKERR( rval, "update failed" );
01513     RETURN( iBase_SUCCESS );
01514 }
01515
01516 void iMeshP_pushTags( iMesh_Instance instance,
01517                       const iMeshP_PartitionHandle partition_handle,
01518                       iBase_TagHandle source_tag,
01519                       iBase_TagHandle dest_tag,
01520                       int entity_type,
01521                       int entity_topo,
01522                       int* err )
01523 {
01524     ParallelComm* pcomm = PCOMM;
01525     DimensionPair types;
01526     if( entity_topo != iMesh_ALL_TOPOLOGIES )
01527         types.first = types.second = mb_topology_table[entity_topo];
01528     else if( entity_type != iBase_ALL_TYPES )
01529         // types = CN::TypeDimensionMap[entity_type];
01530         types = CN::getDimPair( entity_type );
01531     else
01532     {
01533         types.first  = MBVERTEX;
01534         types.second = MBENTITYSET;
01535         --types.second;
01536     }
01537
01538     std::vector< Tag > src_tags( 1, itaps_cast< Tag >( source_tag ) );
01539     std::vector< Tag > dst_tags( 1, itaps_cast< Tag >( dest_tag ) );
01540
01541     ErrorCode rval;
01542     Range entities;
01543     for( EntityType t = types.first; t <= types.second; ++t )
01544     {
01545         rval = MOABI->get_entities_by_type_and_tag( 0, t, &src_tags[0], 0, 1, entities, Interface::UNION );CHKERR( rval, "error getting entities to push" );
01546     }
01547
01548     rval = pcomm->exchange_tags( src_tags, dst_tags, entities );CHKERR( rval, "tag data communication failed" );
01549     RETURN( iBase_SUCCESS );
01550 }
01551
01552 void iMeshP_pushTagsEnt( iMesh_Instance instance,
01553                          const iMeshP_PartitionHandle partition_handle,
01554                          iBase_TagHandle source_tag,
01555                          iBase_TagHandle dest_tag,
01556                          const iBase_EntityHandle* entities,
01557                          int entities_size,
01558                          int* err )
01559 {
01560
01561     Range range;
01562     const EntityHandle* ents = itaps_cast< const EntityHandle* >( entities );
01563     std::copy( ents, ents + entities_size, range_inserter( range ) );
01564
01565     std::vector< Tag > src_tags( 1, itaps_cast< Tag >( source_tag ) );
01566     std::vector< Tag > dst_tags( 1, itaps_cast< Tag >( dest_tag ) );
01567     ParallelComm* pcomm = PCOMM;
01568     ErrorCode rval      = pcomm->exchange_tags( src_tags, dst_tags, range );CHKERR( rval, "tag data communication failed" );
01569     RETURN( iBase_SUCCESS );
01570 }
01571
01572 void iMeshP_iPushTags( iMesh_Instance instance,
01573                        const iMeshP_PartitionHandle,
01574                        iBase_TagHandle,
01575                        iBase_TagHandle,
01576                        int,
01577                        int,
01578                        iMeshP_RequestHandle*,
01579                        int* err )
01580 {
01581     FIXME;
01582     RETURN( iBase_NOT_SUPPORTED );
01583 }
01584
01585 void iMeshP_iPushTagsEnt( iMesh_Instance instance,
01586                           const iMeshP_PartitionHandle,
01587                           iBase_TagHandle,
01588                           iBase_TagHandle,
01589                           const iBase_EntityHandle*,
01590                           int,
01591                           iMeshP_RequestHandle*,
01592                           int* err )
01593 {
01594     FIXME;
01595     RETURN( iBase_NOT_SUPPORTED );
01596 }
01597
01598 void iMeshP_createGhostEntsAll( iMesh_Instance instance,
01599                                 iMeshP_PartitionHandle partition_handle,
01600                                 int ghost_dim,
01601                                 int bridge_dim,
01602                                 int num_layers,
01603                                 int include_copies,
01604                                 int* err )
01605 {
01606     if( include_copies )
01607     {
01608         FIXME;
01609         RETURN( iBase_NOT_SUPPORTED );
01610     }
01611
01612     ParallelComm* pcomm = PCOMM;
01613     ErrorCode rval;
01614     if( iBase_ALL_TYPES == ghost_dim ) ghost_dim = -1;
01615     rval = pcomm->exchange_ghost_cells( ghost_dim, bridge_dim, num_layers, 0, true );CHKERR( rval, "ghost exchange failed" );
01616     RETURN( iBase_SUCCESS );
01617 }
01618
01619 void iMeshP_deleteGhostEntsAll( iMesh_Instance instance, iMeshP_PartitionHandle, int* err )
01620 {
01621     FIXME;
01622     RETURN( iBase_NOT_SUPPORTED );
01623 }
01624
01625 void iMeshP_ghostEntInfo( const iMesh_Instance instance,
01626                           const iMeshP_PartitionHandle,
01627                           int*,
01628                           int*,
01629                           int**,
01630                           int**,
01631                           int**,
01632                           int* err )
01633 {
01634     FIXME;
01635     RETURN( iBase_NOT_SUPPORTED );
01636 }
01637
01638 // append the specified option if it isn't already there; returns whether this
01639 // function actually appended it or not
01640 static bool append_option( std::string& opt, const char* option, const char* default_value = 0 )
01641 {
01642     std::string::size_type i;
01643
01644     const char sep = ' ';
01645
01646     if( strchr( option, sep ) || ( default_value && strchr( default_value, sep ) ) )
01647     {
01648         // options can't have a separator in them; XXX work around this
01649         return false;  // iBase_INVALID_ARGUMENT;
01650     }
01651
01652     // search for the required option
01653     std::string search( &sep, 1 );
01654     search += option;
01655     const std::string::size_type sl = search.length();
01656     i                               = opt.find( search );
01657     while( i != std::string::npos )
01658     {
01659         std::string::size_type end = i + sl;
01660         if( end == opt.size() || opt[end] == sep || opt[end] == '=' ) break;
01661         i = end;
01662     }
01663
01664     // if string already contained the option, just return
01665     if( i != std::string::npos ) return false;
01666
01667     opt += search;
01668     if( default_value )
01669     {
01670         opt += "=";
01671         opt += default_value;
01672     }
01673
01674     return true;
01675 }
01676
01677 void iMeshP_loadAll( iMesh_Instance instance,
01678                      const iMeshP_PartitionHandle partition,
01679                      const iBase_EntitySetHandle entity_set_handle,
01680                      const char* name,
01681                      const char* options,
01682                      int* err,
01683                      int name_len,
01684                      int options_len )
01685 {
01686     ErrorCode rval;
01687
01688     // create partition set if user didn't give us one.
01689     EntityHandle partitioning;
01690     if( partition )
01691     {
01692         partitioning = itaps_cast< EntityHandle >( partition );
01693     }
01694     else
01695     {
01696         rval = MOABI->create_meshset( MESHSET_SET, partitioning );CHKERR( rval, "failed to create meshset" );
01697     }
01698
01699     // get ParallelComm for partition
01700     MPI_Comm default_comm = MPI_COMM_WORLD;
01701     ParallelComm* pcomm   = ParallelComm::get_pcomm( MOABI, partitioning, &default_comm );
01702     if( !pcomm )
01703     {
01704         RETURN( iBase_FAILURE );
01705     }
01706
01707     // add necessary values to options string
01708     std::string opt = std::string( options, options + options_len );
01709
01710     if( append_option( opt, "moab:PARALLEL" ) )
01711     {
01712         // only append these other ones if the parallel option wasn't there originally
01713         append_option( opt, "moab:PARTITION_DISTRIBUTE" );
01714         append_option( opt, "moab:PARALLEL_RESOLVE_SHARED_ENTS" );
01715         std::ostringstream id;
01716         id << pcomm->get_id();
01717         append_option( opt, "moab:PCOMM", id.str().c_str() );
01718     }
01719
01720     // load the file
01721     iMesh_load( instance, entity_set_handle, name, opt.c_str(), err, name_len, opt.length() );
01722     if( *err ) return;
01723
01724     rval = pcomm->collective_sync_partition();CHKERR( rval, "collective sync failed" );
01725     RETURN( iBase_SUCCESS );
01726 }
01727
01728 void iMeshP_saveAll( iMesh_Instance instance,
01729                      const iMeshP_PartitionHandle partition,
01730                      const iBase_EntitySetHandle entity_set_handle,
01731                      const char* name,
01732                      const char* options,
01733                      int* err,
01734                      const int name_len,
01735                      int options_len )
01736 {
01737     EntityHandle set;
01738     set = entity_set_handle ? itaps_cast< EntityHandle >( entity_set_handle ) : itaps_cast< EntityHandle >( partition );
01739     iMesh_save( instance, itaps_cast< iBase_EntitySetHandle >( set ), name, options, err, name_len, options_len );
01740 }
01741
01742 //  Map from processes to parts:
01743 //  Given a partition handle and a process rank,
01744 //  return the part handles owned by the process.
01745 //  COMMUNICATION:  None++.
01746 void iMeshP_getPartsOnRank( iMesh_Instance instance,
01747                             const iMeshP_PartitionHandle partition_handle,
01748                             /*in*/ const int /*rank*/,
01749                             /*inout*/ iMeshP_PartHandle** part_handles,
01750                             /*inout*/ int* part_handles_allocated,
01751                             /*out*/ int* part_handles_size,
01752                             int* err )
01753 {
01754     EntityHandle p   = itaps_cast< EntityHandle >( partition_handle );
01755     ParallelComm* pc = ParallelComm::get_pcomm( MOABI, p );
01756     if( !pc ) RETURN( iBase_ERROR_MAP[MB_FAILURE] );
01757
01758     Range part_sets;
01759
01760     ALLOC_CHECK_ARRAY_NOFAIL( part_handles, pc->partition_sets().size() );
01761     Range::iterator rit;
01762     int i;
01763     for( i = 0, rit = pc->partition_sets().begin(); rit != pc->partition_sets().end(); ++rit, i++ )
01764         ( *part_handles )[i] = itaps_cast< iMeshP_PartHandle >( *rit );
01765
01766     RETURN( iBase_SUCCESS );
01767 }
01768
01769 void iMeshP_getPartsArrOnRank( iMesh_Instance instance,
01770                                const iMeshP_PartitionHandle partition_handle,
01771                                /*in*/ const int* rank,
01772                                /*in*/ const int rank_size,
01773                                /*inout*/ iMeshP_PartHandle** part_handles,
01774                                /*inout*/ int* part_handles_allocated,
01775                                /*out*/ int* part_handles_size,
01776                                int* err )
01777 {
01778     EntityHandle p   = itaps_cast< EntityHandle >( partition_handle );
01779     ParallelComm* pc = ParallelComm::get_pcomm( MOABI, p );
01780     if( !pc ) RETURN( iBase_ERROR_MAP[MB_FAILURE] );
01781
01782     if( rank[0] != (int)pc->proc_config().proc_rank() || rank_size > 1 )
01783     {
01784         RETURN( iBase_ERROR_MAP[MB_NOT_IMPLEMENTED] );
01785     }
01786
01787     iMeshP_getPartsOnRank( instance, partition_handle, rank[0], part_handles, part_handles_allocated, part_handles_size,
01788                            err );
01789 }
01790
01791 /** \brief Assign a global id space to entities
01792  * Assign a global id space to entities and vertices, and optionally intermediate-dimension entities
01793  *
01794  *  COMMUNICATION:  Collective.
01795  */
01796 void iMeshP_assignGlobalIds( iMesh_Instance instance,
01797                              const iMeshP_PartitionHandle partition,
01798                              const iBase_EntitySetHandle this_set,
01799                              const int dimension,
01800                              const int start_id,
01801                              const int largest_dim_only,
01802                              const int parallel,
01803                              const int owned_only,
01804                              int* err )
01805 {
01806     ErrorCode rval;
01807
01808     // get partition set
01809     EntityHandle partitionset = itaps_cast< EntityHandle >( partition );
01810     if( !partitionset )
01811     {
01812         rval = MB_FAILURE;CHKERR( rval, "failed to get partition set" );
01813     }
01814
01815     EntityHandle this_mb_set = itaps_cast< EntityHandle >( this_set );
01816
01817     // get ParallelComm for partition
01818     MPI_Comm default_comm;
01819     ParallelComm* pcomm = ParallelComm::get_pcomm( MOABI, partitionset, &default_comm );
01820     if( !pcomm )
01821     {
01822         RETURN( iBase_FAILURE );
01823     }
01824
01825     rval = pcomm->assign_global_ids( this_mb_set, dimension, start_id, largest_dim_only, parallel, owned_only );
01826
01827     RETURN( rval );
01828 }
01829
01830 void iMeshP_getCommunicator( iMesh_Instance instance, int* fcomm, MPI_Comm* ccomm, int* err )
01831 {
01832     *ccomm = MPI_Comm_f2c( *fcomm );
01833     RETURN( iBase_SUCCESS );
01834 }
01835
01836 #ifdef __cplusplus
01837 }  // extern "C"
01838 #endif