|
MOAB: Mesh Oriented datABase
(version 5.4.1)
|
|
MOAB: Mesh Oriented datABase
(version 5.4.1)
|
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
1.7.6.1 
