moab::Intx2MeshEdges Class Reference

#include <Intx2MeshEdges.hpp>

Inheritance diagram for moab::Intx2MeshEdges:

Collaboration diagram for moab::Intx2MeshEdges:

Public Member Functions
	Intx2MeshEdges (Interface *mbimpl, IntxAreaUtils::AreaMethod amethod=IntxAreaUtils::lHuiller)
virtual	~Intx2MeshEdges ()
ErrorCode	EdgeSplits (double areaTolerance)
Public Member Functions inherited from moab::Intx2MeshOnSphere
	Intx2MeshOnSphere (Interface *mbimpl, IntxAreaUtils::AreaMethod amethod=IntxAreaUtils::lHuiller)
virtual	~Intx2MeshOnSphere ()
void	set_radius_source_mesh (double radius)
void	set_radius_destination_mesh (double radius)
double	setup_tgt_cell (EntityHandle tgt, int &nsTgt)
ErrorCode	computeIntersectionBetweenTgtAndSrc (EntityHandle tgt, EntityHandle src, double *P, int &nP, double &area, int markb[MAXEDGES], int markr[MAXEDGES], int &nsSrc, int &nsTgt, bool check_boxes_first=false)
ErrorCode	findNodes (EntityHandle tgt, int nsTgt, EntityHandle src, int nsSrc, double *iP, int nP)
ErrorCode	update_tracer_data (EntityHandle out_set, Tag &tagElem, Tag &tagArea)
Public Member Functions inherited from moab::Intx2Mesh
	Intx2Mesh (Interface *mbimpl)
virtual	~Intx2Mesh ()
ErrorCode	intersect_meshes (EntityHandle mbs1, EntityHandle mbs2, EntityHandle &outputSet)
ErrorCode	intersect_meshes_kdtree (EntityHandle mbset1, EntityHandle mbset2, EntityHandle &outputSet)
virtual ErrorCode	FindMaxEdgesInSet (EntityHandle eset, int &max_edges)
virtual ErrorCode	FindMaxEdges (EntityHandle set1, EntityHandle set2)
virtual ErrorCode	createTags ()
virtual ErrorCode	filterByMask (Range &cells)
ErrorCode	DetermineOrderedNeighbors (EntityHandle inputSet, int max_edges, Tag &neighTag)
void	set_error_tolerance (double eps)
void	clean ()
void	set_box_error (double berror)
ErrorCode	create_departure_mesh_2nd_alg (EntityHandle &euler_set, EntityHandle &covering_lagr_set)
ErrorCode	create_departure_mesh_3rd_alg (EntityHandle &lagr_set, EntityHandle &covering_set)
void	correct_polygon (EntityHandle *foundIds, int &nP)

Private Member Functions
ErrorCode	orderSubEdges (std::vector< EntityHandle > &subEdges, std::vector< EntityHandle > &VerticesSubEdges, const EntityHandle *connEdge, std::vector< EntityHandle > &chainVertices, std::vector< int > &polygonIds, Tag otherParentTag)

Private Attributes
std::map< EntityHandle, std::vector< EntityHandle > >	edgeVertices
std::map< EntityHandle, std::vector< int > >	edgePolygons
Range	recoveredCells

Additional Inherited Members
Public Attributes inherited from moab::Intx2MeshOnSphere
const IntxAreaUtils::AreaMethod	areaMethod
Protected Attributes inherited from moab::Intx2Mesh
Interface *	mb
EntityHandle	mbs1
EntityHandle	mbs2
Range	rs1
Range	rs2
EntityHandle	outSet
Tag	gid
Tag	TgtFlagTag
Range	TgtEdges
Tag	tgtParentTag
Tag	srcParentTag
Tag	countTag
Tag	srcNeighTag
Tag	tgtNeighTag
Tag	neighTgtEdgeTag
Tag	orgSendProcTag
Tag	imaskTag
	for coverage mesh, will store the original sender More...
const EntityHandle *	tgtConn
const EntityHandle *	srcConn
CartVect	tgtCoords [MAXEDGES]
CartVect	srcCoords [MAXEDGES]
double	tgtCoords2D [MAXEDGES2]
double	srcCoords2D [MAXEDGES2]
std::vector< std::vector< EntityHandle > * >	extraNodesVec
double	epsilon_1
double	epsilon_area
std::vector< double >	allBoxes
double	box_error
EntityHandle	localRoot
Range	localEnts
unsigned int	my_rank
int	max_edges_1
int	max_edges_2
int	counting

Detailed Description

Definition at line 37 of file Intx2MeshEdges.hpp.

Constructor & Destructor Documentation

Intx2MeshEdges()

moab::Intx2MeshEdges::Intx2MeshEdges	(	Interface *	mbimpl,
		IntxAreaUtils::AreaMethod	amethod = IntxAreaUtils::lHuiller
	)

Definition at line 16 of file Intx2MeshEdges.cpp.

    : Intx2MeshOnSphere( mbimpl, amethod )
{
}

~Intx2MeshEdges()

moab::Intx2MeshEdges::~Intx2MeshEdges ( )

virtual

Definition at line 21 of file Intx2MeshEdges.cpp.

{
    // TODO Auto-generated destructor stub
}

Member Function Documentation

EdgeSplits()

ErrorCode moab::Intx2MeshEdges::EdgeSplits

(

double

areaTolerance

)

Definition at line 87 of file Intx2MeshEdges.cpp.

{
 
    Tag parentTag, otherParentTag;
    ErrorCode rval;
 
    rval = mb->tag_get_handle( "TargetParent", parentTag );MB_CHK_SET_ERR( rval, "can't get parent target tag in edge map" );
    rval = mb->tag_get_handle( "SourceParent", otherParentTag );MB_CHK_SET_ERR( rval, "can't get parent source tag in edge map" );
 
    Tag fractionTag;
    rval = mb->tag_get_handle( "EdgeRecoveryFraction", fractionTag );MB_CHK_SET_ERR( rval, "can't get tag for recovery fraction" );
    Tag subTag;
    rval = mb->tag_get_handle( "NumSubEnts", subTag );MB_CHK_SET_ERR( rval, "can't get tag NumSubEdges" );
    Tag areaDiffTag;
    rval = mb->tag_get_handle( "AreaDiff", areaDiffTag );MB_CHK_SET_ERR( rval, "can't get tag AreaDiff" );
    Tag areaTag;
    rval = mb->tag_get_handle( "Area", areaTag );MB_CHK_SET_ERR( rval, "can't get tag Area" );
 
    Range parentCells;
    rval = mb->get_entities_by_dimension( mbs2, 2, parentCells );MB_CHK_SET_ERR( rval, "can't get parent cells" );
    Range initialEdges;
    // we will assume the edges are already included in the target mesh
    // we do not want to create them
    rval = mb->get_adjacencies( parentCells, 1, false, initialEdges, Interface::UNION );MB_CHK_SET_ERR( rval, "can't get parent edges" );
    std::cout << " number of original input edges:" << initialEdges.size() << "\n";
 
    // get all polygons in the intx set
    Range cells;
    rval = mb->get_entities_by_dimension( outSet, 2, cells );MB_CHK_SET_ERR( rval, "can't get intersection cells" );
    // create all edges adjacent to the cells in the intx set
    // some might be original edges from edge or target meshes
    Range intxEdges;
    rval = mb->get_adjacencies( cells, 1, true, intxEdges, Interface::UNION );MB_CHK_SET_ERR( rval, "can't create adjacent intx edges " );
    std::cout << " number of intx edges:" << intxEdges.size() << "\n";
 
    // first, identify input polygons that are recovered fully
    // get global ids of the initial cells
    std::vector< int > parentGids( parentCells.size() );
    Tag gidTag = mb->globalId_tag();
    rval       = mb->tag_get_data( gidTag, parentCells, &parentGids[0] );MB_CHK_SET_ERR( rval, "can't get parent global ids" );
    std::map< int, double > initAreas;  // get areas of those initial cells
    int i = 0;
    std::vector< double > coords( 3 * 20 );  // enough vertices, at most 30, good for intx polygons too
    int num_nodes = 0;                       // num nodes in cells
    const EntityHandle* verts;
    IntxAreaUtils areaAdaptor( IntxAreaUtils::lHuiller );  // GaussQuadrature , lHuiller
    std::map< int, double > recoveredAreas;                // get areas of from intersection cells
    std::map< int, EntityHandle > mapFromGIDToParent;
    std::map< int, std::vector< EntityHandle > > mapFromParentGIDToIntxCells;
    for( Range::iterator it = parentCells.begin(); it != parentCells.end(); ++it, i++ )
    {
        EntityHandle parentCell = *it;
        rval                    = mb->get_connectivity( parentCell, verts, num_nodes );MB_CHK_SET_ERR( rval, "can't get connectivity of parent cell" );
        // get coordinates
        rval = mb->get_coords( verts, num_nodes, &coords[0] );MB_CHK_SET_ERR( rval, "can't get coords of parent cell" );
 
        double area = areaAdaptor.area_spherical_polygon( &coords[0], num_nodes, 1. );
        rval        = mb->tag_set_data( areaTag, &parentCell, 1, &area );MB_CHK_SET_ERR( rval, "can't set area Tag on parent cell" );
        int parentID                 = parentGids[i];
        initAreas[parentID]          = area;
        recoveredAreas[parentID]     = 0.;
        mapFromGIDToParent[parentID] = parentCell;
        mapFromParentGIDToIntxCells[parentID];  // just initialize it with empty vector
    }
 
    for( Range::iterator it = cells.begin(); it != cells.end(); ++it )
    {
        EntityHandle cell = *it;
        rval              = mb->get_connectivity( cell, verts, num_nodes );MB_CHK_SET_ERR( rval, "can't get connectivity of intx cell" );
        // get coordinates
        rval = mb->get_coords( verts, num_nodes, &coords[0] );MB_CHK_SET_ERR( rval, "can't get coods of intx cell" );
        double intx_area = areaAdaptor.area_spherical_polygon( &coords[0], num_nodes, 1. );
        int parentID     = 0;
        rval             = mb->tag_get_data( parentTag, &cell, 1, &parentID );MB_CHK_SET_ERR( rval, "can't get parent Tag" );
        recoveredAreas[parentID] += intx_area;
        mapFromParentGIDToIntxCells[parentID].push_back( cell );
    }
    int recovered = 0, notRecovered = 0;
    //Range recoveredCells;
    for( size_t j = 0; j < parentGids.size(); j++ )
    {
        int parentID            = parentGids[j];
        EntityHandle parentCell = parentCells[j];
        double areaDiff         = initAreas[parentID] - recoveredAreas[parentID];
        rval                    = mb->tag_set_data( areaDiffTag, &parentCell, 1, &areaDiff );MB_CHK_SET_ERR( rval, "can't set diff area Tag" );
        double numIntxcells = static_cast< double >( mapFromParentGIDToIntxCells[parentID].size() );
        rval                = mb->tag_set_data( subTag, &parentCell, 1, &numIntxcells );MB_CHK_SET_ERR( rval, "can't set num sub ents Tag" );
        if( fabs( areaDiff ) < areaTolerance )
        {
            recovered++;
            recoveredCells.insert( parentCells[j] );  // should we use a std::vector, that will be ordered already ?
        }
        else
            notRecovered++;
    }
    std::cout << "recovered initial cells: " << recovered << " vs:" << notRecovered << " not recovered \n";
    // initial edges that should be decomposable from intx edges
    Range recoverableEdges;
    rval = mb->get_adjacencies( recoveredCells, 1, false, recoverableEdges, Interface::UNION );MB_CHK_SET_ERR( rval, "can't get recoverable edges" );
 
    // now recover each edge, looking at intx polygons forming one of the adjacent cells, that is in initial recoverable set
    int recoveredEdges = 0;
    int unrecovered    = 0;
    int identity_edges = 0;  // edges that are formed by one intx edge, itself, the original
    std::map< EntityHandle, std::vector< EntityHandle > > mapEdges;
    for( Range::iterator eit = recoverableEdges.begin(); eit != recoverableEdges.end(); ++eit )
    {
        EntityHandle initialEdge = *eit;
        // if this edge is among intxEdges, we are done
        int index = intxEdges.index( initialEdge );
        if( index >= 0 )
        {
            mapEdges[initialEdge].push_back( initialEdge );
            identity_edges++;
            recoveredEdges++;
            double numSubEdges = 1.;
            rval               = mb->tag_set_data( subTag, &initialEdge, 1, &numSubEdges );MB_CHK_SET_ERR( rval, "can't set num sub ents Tag" );
            // get vertices and intx poly attached to it
            int nve = 0;
            const EntityHandle* connCell;
            rval = mb->get_connectivity( initialEdge, connCell, nve );MB_CHK_SET_ERR( rval, "can't get connectivity of parent cell" );
            edgeVertices[initialEdge].push_back( connCell[0] );
            edgeVertices[initialEdge].push_back( connCell[1] );
            // find cells in intx set adjacent to it, and get the other tag parent
            Range adjPolys;
            rval = mb->get_adjacencies( &initialEdge, 1, 2, false, adjPolys, Interface::UNION );MB_CHK_SET_ERR( rval, "can't get adj polys" );
            adjPolys = subtract( adjPolys, parentCells );
            if( adjPolys.empty() ) MB_CHK_SET_ERR( MB_FAILURE, "no adjacent intx cells" );
            EntityHandle intxPoly = adjPolys[0];
            // get its parent tag
            int gid;
            rval = mb->tag_get_data( otherParentTag, &intxPoly, 1, &gid );MB_CHK_SET_ERR( rval, "can't get global id from other tag" );
            edgePolygons[initialEdge].push_back( gid );
            continue;  // no need to sweat it anymore
        }
        // get adjacent polygons; if there is an adj polygon in intx cells, we are done; if not, get one in the initial recoveredCells range
        Range initialAdjCells;
        rval = mb->get_adjacencies( &initialEdge, 1, 2, false, initialAdjCells, Interface::UNION );MB_CHK_SET_ERR( rval, "can't get adjacent initial cells" );
        if( initialAdjCells.size() == 0 ) MB_CHK_SET_ERR( MB_FAILURE, "no adjacent initial cells" );
        // intersect with recoveredCells
        Range adjRecoveredInitialCell = intersect( initialAdjCells, recoveredCells );
        if( adjRecoveredInitialCell.size() == 0 )
            MB_CHK_SET_ERR( MB_FAILURE, "no adjacent initial cells that are recovered" );
        // get all edges adjacent to intersection polygons that form one of the recovered initial cell
        EntityHandle recoveredCell = adjRecoveredInitialCell[0];  // first one
        int nv                     = 0;
        const EntityHandle* connCell;
        rval = mb->get_connectivity( recoveredCell, connCell, nv );MB_CHK_SET_ERR( rval, "can't get connectivity of parent cell" );
        int cellGlobalId = 0;
        rval             = mb->tag_get_data( gidTag, &recoveredCell, 1, &cellGlobalId );MB_CHK_SET_ERR( rval, "can't get id of parent cell" );
        // list of intx polygons in it:
        std::vector< EntityHandle >& listIntxCells = mapFromParentGIDToIntxCells[cellGlobalId];
        std::vector< EntityHandle > candidateEdges;
        rval =
            mb->get_adjacencies( &listIntxCells[0], listIntxCells.size(), 1, false, candidateEdges, Interface::UNION );MB_CHK_SET_ERR( rval, "can't get adj edges" );
        // add all edges that have both vertices on the original edge
        CartVect verticesOriginal[2];
        const EntityHandle* connEdge;
        int numVerts = 0;
        rval         = mb->get_connectivity( initialEdge, connEdge, numVerts );MB_CHK_SET_ERR( rval, "can't get connectivity of initial edge" );
 
        rval = mb->get_coords( connEdge, numVerts, verticesOriginal[0].array() );MB_CHK_SET_ERR( rval, "can't get coordinates of vertices of initial edge" );
        // get gnomonic plane for the start of the edge
        int gnomonicPlane = 0;
        IntxUtils::decide_gnomonic_plane( verticesOriginal[0], gnomonicPlane );
        double coords2D[6];  // coords in gnomonic plane, for interior point decision
        rval = IntxUtils::gnomonic_projection( verticesOriginal[0], 1.0, gnomonicPlane, coords2D[0], coords2D[1] );MB_CHK_SET_ERR( rval, "can't get gnomonic coords" );
        rval = IntxUtils::gnomonic_projection( verticesOriginal[1], 1.0, gnomonicPlane, coords2D[2], coords2D[3] );MB_CHK_SET_ERR( rval, "can't get gnomonic coords" );
 
        double edgeLength =
            angle_robust( verticesOriginal[0], verticesOriginal[1] );  // distance on sphere of radius 1 is the angle
        // loop now over candidateEdges
        double recoveredLength = 0.;
        std::vector< EntityHandle > VerticesSubEdges;  // push all vertices here, so we can order the subedges later
        for( size_t i = 0; i < candidateEdges.size(); i++ )
        {
            EntityHandle subedge = candidateEdges[i];
            // get its vertex coordinates:
            const EntityHandle* connEdge2;
            rval = mb->get_connectivity( subedge, connEdge2, numVerts );MB_CHK_SET_ERR( rval, "can't get connectivity of candidate edge" );
            CartVect verticesSubEdge[2];
            rval = mb->get_coords( connEdge2, numVerts, verticesSubEdge[0].array() );MB_CHK_SET_ERR( rval, "can't get coordinates of vertices of initial edge" );
            // decide if they are on the initial edge (form an angle)
            bool onEdge = true;
            for( int j = 0; j < 2 && onEdge; j++ )
            {
                rval =
                    IntxUtils::gnomonic_projection( verticesSubEdge[j], 1.0, gnomonicPlane, coords2D[4], coords2D[5] );MB_CHK_SET_ERR( rval, "can't get gnomonic coords of subedge" );
                // area of triangle in gnomonic plane should be 0
                double areaAbs = fabs( IntxUtils::area2D( &coords2D[0], &coords2D[2], &coords2D[4] ) );
 
                if( areaAbs > 1.e-14 ) onEdge = false;
            }
            if( onEdge )
            {
                double subEdgeLen = angle_robust( verticesSubEdge[0], verticesSubEdge[1] );
                recoveredLength += subEdgeLen;
                mapEdges[initialEdge].push_back( subedge );
                VerticesSubEdges.push_back( connEdge2[0] );
                VerticesSubEdges.push_back( connEdge2[1] );
            }
        }
        double fraction = recoveredLength / edgeLength;
        rval            = mb->tag_set_data( fractionTag, &initialEdge, 1, &fraction );MB_CHK_SET_ERR( rval, "can't set fraction on initial edge" );
        double numSubEdge = double( mapEdges[initialEdge].size() );
        rval              = mb->tag_set_data( subTag, &initialEdge, 1, &numSubEdge );MB_CHK_SET_ERR( rval, "can't set number of subedges on initial edge" );
        // now , reorder the subedges to create a chain along the original edge
        // if we cannot form a chain, it means we have a problem
        // order subedges on the original edge, and find out their orientation
        // set also the parent tag on the edge, either source or target parent
        // in some cases, the parents can be both
        rval = orderSubEdges( mapEdges[initialEdge], VerticesSubEdges, connEdge, edgeVertices[initialEdge],
                              edgePolygons[initialEdge], otherParentTag );
        if( fabs( edgeLength - recoveredLength ) < 1.e-10 || rval == MB_SUCCESS )
            recoveredEdges++;
        else
        {
            mb->list_entity( initialEdge );
            std::vector< EntityHandle >& listSubEdges = mapEdges[initialEdge];
            double newCheckLength                     = 0;
            CartVect vertices[2];
            const EntityHandle* conn2;
            int numVerts2 = 0;
            rval          = mb->get_connectivity( initialEdge, conn2, numVerts2 );MB_CHK_SET_ERR( rval, "can't get connectivity of initial edge " );
            rval = mb->get_coords( conn2, numVerts2, vertices[0].array() );MB_CHK_SET_ERR( rval, "can't get coordinates of vertices of initial edge" );
            double length2 = angle_robust( vertices[0], vertices[1] );
            std::cout << std::setprecision( 14 );
            std::cout << " initial edge:" << mb->id_from_handle( initialEdge ) << " v: " << conn2[0] << ", " << conn2[1]
                      << " len: " << length2 << "\n";
            for( size_t j = 0; j < listSubEdges.size(); j++ )
            {
                EntityHandle subEdge = listSubEdges[j];
                rval                 = mb->get_connectivity( subEdge, conn2, numVerts2 );MB_CHK_SET_ERR( rval, "can't get connectivity of subedge " );
                rval = mb->get_coords( conn2, numVerts2, vertices[0].array() );MB_CHK_SET_ERR( rval, "can't get coordinates of vertices of subedge" );
                length2 = angle_robust( vertices[0], vertices[1] );
                newCheckLength += length2;
                std::cout << "     sub edge:" << mb->id_from_handle( subEdge ) << " v: " << conn2[0] << ", " << conn2[1]
                          << " len: " << length2 << "\n";
            }
            std::cout << " edge length:" << edgeLength << " newCheckLength:" << newCheckLength
                      << " diff:" << edgeLength - newCheckLength << " fraction:" << fraction
                      << " subedges:" << numSubEdge << "\n";
            unrecovered++;
            std::cout << std::setprecision( 7 );
        }
    }
 
    std::cout << " recoveredEdges:" << recoveredEdges << " identity edges:" << identity_edges
              << " unrecovered edges:" << unrecovered << "\n";
    return MB_SUCCESS;
}

References moab::angle_robust(), moab::IntxUtils::area2D(), moab::IntxAreaUtils::area_spherical_polygon(), moab::Range::begin(), moab::IntxUtils::decide_gnomonic_plane(), edgePolygons, edgeVertices, moab::Range::empty(), moab::Range::end(), ErrorCode, moab::Interface::get_adjacencies(), moab::Interface::get_connectivity(), moab::Interface::get_coords(), moab::Interface::get_entities_by_dimension(), moab::Intx2Mesh::gid, moab::Interface::globalId_tag(), moab::IntxUtils::gnomonic_projection(), moab::Interface::id_from_handle(), moab::index, moab::Range::index(), moab::Range::insert(), moab::intersect(), moab::IntxAreaUtils::lHuiller, moab::Interface::list_entity(), moab::Intx2Mesh::mb, MB_CHK_SET_ERR, MB_SUCCESS, moab::Intx2Mesh::mbs2, orderSubEdges(), moab::Intx2Mesh::outSet, recoveredCells, moab::Range::size(), moab::subtract(), moab::Interface::tag_get_data(), moab::Interface::tag_get_handle(), moab::Interface::tag_set_data(), and moab::Interface::UNION.

Referenced by main().

orderSubEdges()

ErrorCode moab::Intx2MeshEdges::orderSubEdges ( std::vector< EntityHandle > &  subEdges, std::vector< EntityHandle > &  VerticesSubEdges, const EntityHandle *  connEdge, std::vector< EntityHandle > &  chainVertices, std::vector< int > &  polygonIds, Tag  otherParentTag  )

private

Definition at line 27 of file Intx2MeshEdges.cpp.

{
    int numEdges = (int)subEdges.size();
    if( numEdges == 1 ) return MB_SUCCESS;  // nothing to do
 
    EntityHandle currentVertex = connEdge[0];  // start vertex
    chainVertices.push_back( currentVertex );
    EntityHandle endVertex = connEdge[1];
    std::vector< EntityHandle > chain;
    std::vector< int > markedEdge( numEdges, 0 );  // 0 means not found yet; -1 or +1 for orientation
    // start finding the current vertex, until we close the chain; double loop, we could be smarter :)
    for( int i = 0; i < numEdges; i++ )
    {
        for( int j = 0; j < numEdges; j++ )
        {
            if( 0 != markedEdge[j] ) continue;  // do not use it anymore
            if( VerticesSubEdges[j * 2] == currentVertex )
            {
                currentVertex = VerticesSubEdges[j * 2 + 1];
                chainVertices.push_back( currentVertex );
                chain.push_back( subEdges[j] );
                markedEdge[j] = 1;  // positive
                break;              // break the j loop
            }
            if( VerticesSubEdges[j * 2 + 1] == currentVertex )
            {
                currentVertex = VerticesSubEdges[j * 2];
                chainVertices.push_back( currentVertex );
                chain.push_back( subEdges[j] );
                markedEdge[j] = -1;  // reversed
                break;               // break the j loop
            }
        }
    }
    if( (int)chain.size() == numEdges && currentVertex == endVertex )
    {
        subEdges = chain;  // reordered list, no orientation saved; maybe we should ?
        // from chain, form the list of original polygons that contain each subedge
        // get the parent tag of 2 intx polys connected to each edge in chain
        for( int j = 0; j < (int)chain.size(); j++ )
        {
            EntityHandle sEdge = chain[j];
            std::vector< EntityHandle > intxPolys;
            ErrorCode rval = mb->get_adjacencies( &sEdge, 1, 2, false, intxPolys, Interface::UNION );MB_CHK_ERR( rval );
            EntityHandle onePolygon = intxPolys[0];
            int global_id           = 0;
            rval                    = mb->tag_get_data( otherParentTag, &onePolygon, 1, &global_id );MB_CHK_ERR( rval );
            polygonIds.push_back( global_id );
        }
        return MB_SUCCESS;
    }
    else
        return MB_FAILURE;  // we did not find a chain, do not change anything
}

References ErrorCode, moab::Interface::get_adjacencies(), moab::Intx2Mesh::mb, MB_CHK_ERR, MB_SUCCESS, moab::Interface::tag_get_data(), and moab::Interface::UNION.

Referenced by EdgeSplits().

Member Data Documentation

edgePolygons

std::map< EntityHandle, std::vector< int > > moab::Intx2MeshEdges::edgePolygons

private

Definition at line 68 of file Intx2MeshEdges.hpp.

Referenced by EdgeSplits().

edgeVertices

std::map< EntityHandle, std::vector< EntityHandle > > moab::Intx2MeshEdges::edgeVertices

private

Definition at line 66 of file Intx2MeshEdges.hpp.

Referenced by EdgeSplits().

recoveredCells

Range moab::Intx2MeshEdges::recoveredCells

private

Definition at line 69 of file Intx2MeshEdges.hpp.

Referenced by EdgeSplits().

---

The documentation for this class was generated from the following files:

• Intx2MeshEdges.hpp
• Intx2MeshEdges.cpp