moab::HalfFacetRep Class Reference

#include <HalfFacetRep.hpp>

Collaboration diagram for moab::HalfFacetRep:

Classes
struct	adj_matrix
struct	LocalMaps2D
	2D local maps More...
struct	LocalMaps3D
	3D local maps More...

Public Member Functions
	HalfFacetRep (Core *impl, ParallelComm *comm=0, moab::EntityHandle rset=0, bool filter_ghosts=true)
	~HalfFacetRep ()
bool	check_mixed_entity_type ()
ErrorCode	initialize ()
	Constructs the sibling-half-facet and vertex-to-incident-half-facet maps for each dimension present in the input. This routine should be called before any calls for adjacency is made. More...
ErrorCode	deinitialize ()
	Deinitialize. More...
ErrorCode	print_tags (int dim)
	Prints the tag values. More...
ErrorCode	get_adjacencies (const EntityHandle source_entity, const unsigned int target_dimension, std::vector< EntityHandle > &target_entities)
	Get the adjacencies associated with an entity. More...
ErrorCode	get_up_adjacencies (EntityHandle ent, int out_dim, std::vector< EntityHandle > &adjents, std::vector< int > *lids=NULL)
	Get the upward incidences associated with an entity. More...
ErrorCode	get_neighbor_adjacencies (EntityHandle ent, std::vector< EntityHandle > &adjents)
	Get the same-dimensional entities connected with an entity. More...
ErrorCode	get_down_adjacencies (EntityHandle ent, int out_dim, std::vector< EntityHandle > &adjents)
	Get the downward adjacent entities connected with an entity. More...
ErrorCode	determine_sibling_halfverts (Range &verts, Range &edges)
	Given a range of edges, determines the map for sibling half-verts and stores them into SIBHVS_EID, SIBHVS_LVID tags. More...
ErrorCode	determine_incident_halfverts (Range &edges)
	Given a range of edges, determines the map for incident half-verts and stores them into V2HV_EID, V2HV_LVID tags. More...
ErrorCode	get_up_adjacencies_1d (EntityHandle vid, std::vector< EntityHandle > &adjents, std::vector< int > *lvids=NULL)
	Given a vertex, finds the edges incident on it. More...
ErrorCode	get_neighbor_adjacencies_1d (EntityHandle eid, std::vector< EntityHandle > &adjents)
	Given an edge, finds vertex-connected neighbor edges. More...
ErrorCode	determine_sibling_halfedges (Range &faces)
	Given a range of faces, determines the sibling half-edges and stores them into SIBHES_FID, SIBHES_LEID tags. More...
ErrorCode	determine_incident_halfedges (Range &faces)
	Given a range of faces, determines the incident half-edges and stores them into V2HE_FID, V2HE_LEID tags. More...
ErrorCode	get_up_adjacencies_vert_2d (EntityHandle vid, std::vector< EntityHandle > &adjents)
	Given a vertex, finds the faces incident on it. More...
ErrorCode	get_up_adjacencies_2d (EntityHandle eid, std::vector< EntityHandle > &adjents, std::vector< int > *leids=NULL)
	Given an edge, finds the faces incident on it. More...
ErrorCode	get_up_adjacencies_2d (EntityHandle fid, int leid, bool add_inent, std::vector< EntityHandle > &adj_ents, std::vector< int > *adj_leids=NULL, std::vector< int > *adj_orients=NULL)
	Given a half-edge <fid, leid>, finds the faces incident on it. More...
ErrorCode	get_neighbor_adjacencies_2d (EntityHandle fid, std::vector< EntityHandle > &adjents)
	Given an edge, finds edge-connected neighbor face. More...
ErrorCode	get_down_adjacencies_2d (EntityHandle fid, std::vector< EntityHandle > &adjents)
	Given a face, finds its edges. More...
int	find_total_edges_2d (Range &faces)
	Given a range of faces, finds the total number of edges. More...
ErrorCode	get_face_edges (EntityHandle fid, std::vector< EntityHandle > &edges)
ErrorCode	determine_sibling_halffaces (Range &cells)
	Given a range of cells, determines the sibling half-faces and stores them into SIBHFS_CID, SIBHFS_LFID tags. More...
ErrorCode	determine_incident_halffaces (Range &cells)
	Given a range of cells, determines the incident half-faces and stores them into V2HF_CID, V2HF_LFID tags. More...
ErrorCode	determine_border_vertices (Range &cells, Tag isborder)
	Given a range of cells, tags all border vertices with a true value. More...
ErrorCode	get_up_adjacencies_vert_3d (EntityHandle vid, std::vector< EntityHandle > &adjents)
	Given a vertex, finds the cells incident on it. More...
ErrorCode	get_up_adjacencies_edg_3d (EntityHandle eid, std::vector< EntityHandle > &adjents, std::vector< int > *leids=NULL)
	Given an edge, finds the cells incident on it. More...
ErrorCode	get_up_adjacencies_edg_3d (EntityHandle cid, int leid, std::vector< EntityHandle > &adjents, std::vector< int > *leids=NULL, std::vector< int > *adj_orients=NULL)
	Given a local edge <cid, leid>, finds the cells incident on it. More...
ErrorCode	get_up_adjacencies_edg_3d_comp (EntityHandle cid, int leid, std::vector< EntityHandle > &adjents, std::vector< int > *leids=NULL, std::vector< int > *adj_orients=NULL)
ErrorCode	get_up_adjacencies_face_3d (EntityHandle fid, std::vector< EntityHandle > &adjents, std::vector< int > *lfids=NULL)
	Given an face, finds the cells incident on it. More...
ErrorCode	get_up_adjacencies_face_3d (EntityHandle cid, int lfid, std::vector< EntityHandle > &adjents, std::vector< int > *lfids=NULL)
	Given a local face <cid, lfid>, finds the cells incident on it. More...
ErrorCode	get_neighbor_adjacencies_3d (EntityHandle cid, std::vector< EntityHandle > &adjents)
	Given a cell, finds face-connected neighbor cells. More...
ErrorCode	get_down_adjacencies_edg_3d (EntityHandle cid, std::vector< EntityHandle > &adjents)
	Given a cell, finds its edges. More...
ErrorCode	get_down_adjacencies_face_3d (EntityHandle cid, std::vector< EntityHandle > &adjents)
	Given a cell, finds its faces. More...
ErrorCode	find_total_edges_faces_3d (const Range &cells, int *nedges, int *nfaces)
ErrorCode	count_subentities (Range &edges, Range &faces, Range &cells, int *nedges, int *nfaces)
void	get_memory_use (unsigned long long &entity_total, unsigned long long &memory_total)
ErrorCode	get_half_facet_in_comp (EntityHandle cid, int leid, std::vector< EntityHandle > &ents, std::vector< int > &lids, std::vector< int > &lfids)
HFacet	create_halffacet (EntityHandle handle, int lid)
EntityHandle	fid_from_halfacet (const HFacet facet, EntityType type)
int	lid_from_halffacet (const HFacet facet)
ErrorCode	update_entity_ranges (EntityHandle fileset)
ErrorCode	resize_hf_maps (EntityHandle start_vert, int nverts, EntityHandle start_edge, int nedges, EntityHandle start_face, int nfaces, EntityHandle start_cell, int ncells)
ErrorCode	get_sibling_map (EntityType type, EntityHandle ent, EntityHandle *sib_entids, int *sib_lids, int num_halffacets)
ErrorCode	get_sibling_map (EntityType type, EntityHandle ent, int lid, EntityHandle &sib_entid, int &sib_lid)
ErrorCode	set_sibling_map (EntityType type, EntityHandle ent, EntityHandle *set_entids, int *set_lids, int num_halffacets)
ErrorCode	set_sibling_map (EntityType type, EntityHandle ent, int lid, EntityHandle &set_entid, int &set_lid)
ErrorCode	get_incident_map (EntityType type, EntityHandle vid, std::vector< EntityHandle > &inci_entid, std::vector< int > &inci_lid)
ErrorCode	set_incident_map (EntityType type, EntityHandle vid, std::vector< EntityHandle > &set_entid, std::vector< int > &set_lid)
bool	check_nonmanifold_vertices (EntityType type, EntityHandle vid)
int	get_index_in_lmap (EntityHandle cid)
ErrorCode	get_entity_ranges (Range &verts, Range &edges, Range &faces, Range &cells)
MESHTYPE	get_mesh_type (int nverts, int nedges, int nfaces, int ncells)
EntityHandle *	get_rset ()

Public Attributes
MESHTYPE	thismeshtype
std::map< EntityType, int >	cell_index

Static Public Attributes
static const LocalMaps2D	lConnMap2D [2]
static const LocalMaps3D	lConnMap3D [4]

Protected Member Functions
	HalfFacetRep ()
int	get_index_for_meshtype (MESHTYPE mesh_type)
ErrorCode	init_curve ()
ErrorCode	init_surface ()
ErrorCode	init_volume ()
ErrorCode	get_up_adjacencies_2d (EntityHandle he_fid, int he_lid, int *qsize, int *count)
	Contains the local information for 2D entities. More...
bool	find_matching_halfedge (EntityHandle eid, EntityHandle *hefid, int *helid)
	Given an edge, finds a matching half-edge in the surface. More...
ErrorCode	gather_halfedges (EntityHandle vid, EntityHandle he_fid, int he_lid, int *qsize, int *count)
	Gather half-edges to a queue of half-edges. More...
ErrorCode	another_halfedge (EntityHandle vid, EntityHandle he_fid, int he_lid, EntityHandle *he2_fid, int *he2_lid)
	Obtains another half-edge belonging to the same face as the input half-edge. More...
ErrorCode	mark_halfedges (EntityHandle vid, EntityHandle he_fid, int he_lid, Range &faces, std::vector< char > &markHEdgs, HFacet &bnd_hf)
bool	collect_and_compare (const EntityHandle vid, const EntityHandle *edg_vert, int *qsize, int *count, EntityHandle *he_fid, int *he_lid)
	Collect and compare to find a matching half-edge with the given edge connectivity. More...
ErrorCode	add_cells_of_single_component (EntityHandle vid, EntityHandle curcid, int curlid, std::multimap< EntityHandle, EntityHandle > &comps, HFacet &hf)
bool	find_cell_in_component (EntityHandle vid, EntityHandle cell, std::multimap< EntityHandle, EntityHandle > &comps)
bool	find_matching_implicit_edge_in_cell (EntityHandle eid, std::vector< EntityHandle > &cid, std::vector< int > &leid)
	Given an edge, finds a matching local edge in an incident cell. More...
bool	find_matching_halfface (EntityHandle fid, EntityHandle *cid, int *leid)
	Given a face, finds a matching local face in an incident cell. More...
bool	find_match_in_array (EntityHandle ent, EntityHandle *ent_list, int count, bool get_index=false, int *index=NULL)

Protected Attributes
Core *	mb
ParallelComm *	pcomm
EntityHandle	_rset
bool	_filterghost
bool	mInitAHFmaps
Range	_verts
Range	_edges
Range	_faces
Range	_cells
std::vector< HFacet >	sibhvs
std::vector< HFacet >	v2hv
std::vector< HFacet >	sibhes
std::vector< HFacet >	v2he
std::vector< HFacet >	sibhfs
std::vector< HFacet >	v2hf
std::multimap< EntityHandle, HFacet >	v2hes
std::multimap< EntityHandle, HFacet >	v2hfs
EntityHandle	queue_fid [MAXSIZE]
EntityHandle	Stkcells [MAXSIZE]
EntityHandle	cellq [MAXSIZE]
EntityHandle	trackfaces [MAXSIZE]
EntityHandle	trackcells [MAXSIZE]
int	queue_lid [MAXSIZE]
bool	is_mixed
bool	chk_mixed

Static Protected Attributes
static const adj_matrix	adjMatrix [7]

Detailed Description

Definition at line 76 of file HalfFacetRep.hpp.

Constructor & Destructor Documentation

HalfFacetRep() [1/2]

moab::HalfFacetRep::HalfFacetRep	(	Core *	impl,
		ParallelComm *	comm = 0,
		moab::EntityHandle	rset = 0,
		bool	filter_ghosts = true
	)

Definition at line 45 of file HalfFacetRep.cpp.

    : thismeshtype( CURVE ), mb( impl ), pcomm( comm ), _rset( rset ), _filterghost( filter_ghosts )
{
    assert( NULL != impl );
    mInitAHFmaps = false;
    chk_mixed    = false;
    is_mixed     = false;
}

References chk_mixed, is_mixed, and mInitAHFmaps.

~HalfFacetRep()

moab::HalfFacetRep::~HalfFacetRep

(

)

Definition at line 54 of file HalfFacetRep.cpp.

{}

HalfFacetRep() [2/2]

moab::HalfFacetRep::HalfFacetRep ( )

protected

Member Function Documentation

add_cells_of_single_component()

ErrorCode moab::HalfFacetRep::add_cells_of_single_component ( EntityHandle  vid, EntityHandle  curcid, int  curlid, std::multimap< EntityHandle, EntityHandle > &  comps, HFacet &  hf  )

protected

Definition at line 2062 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityType ctype = mb->type_from_handle( curcid );
    int index        = get_index_in_lmap( curcid );
    int nvpc         = lConnMap3D[index].num_verts_in_cell;
    int nfpc         = lConnMap3D[index].num_faces_in_cell;
 
    int Stksize = 0, count = -1;
    Stkcells[0] = curcid;
 
    hf = create_halffacet( curcid, curlid );
 
    EntityHandle cur_cid;
    while( Stksize >= 0 )
    {
        cur_cid = Stkcells[Stksize];
        Stksize -= 1;
 
        bool found = find_match_in_array( cur_cid, trackcells, count );
        if( !found )
        {
            count += 1;
            trackcells[count] = cur_cid;
 
            // Add the current cell
            comps.insert( std::pair< EntityHandle, EntityHandle >( vid, cur_cid ) );
        }
 
        // Connectivity of the cell
        const EntityHandle* conn;
        error = mb->get_connectivity( cur_cid, conn, nvpc, true );
        MB_CHK_ERR( error );
 
        // Local id of vid in the cell and the half-faces incident on it
        int lv = -1;
        for( int i = 0; i < nvpc; ++i )
        {
            if( conn[i] == vid )
            {
                lv = i;
                break;
            }
        }
        if( lv < 0 ) MB_SET_ERR( MB_FAILURE, "did not find local vertex " );
        int nhf_thisv = lConnMap3D[index].v2hf_num[lv];
        int cidx      = ID_FROM_HANDLE( cur_cid ) - 1;
 
        // Add new cells into the stack
        EntityHandle ngb;
        HFacet hf_ngb;
        for( int i = 0; i < nhf_thisv; ++i )
        {
            int ind = lConnMap3D[index].v2hf[lv][i];
            hf_ngb  = sibhfs[nfpc * cidx + ind];
            ngb     = fid_from_halfacet( hf_ngb, ctype );
 
            if( ngb )
            {
                bool found_ent = find_match_in_array( ngb, trackcells, count );
 
                if( !found_ent )
                {
                    Stksize += 1;
                    Stkcells[Stksize] = ngb;
                }
            }
            else
                hf = create_halffacet( cur_cid, ind );
        }
    }
 
    // Change the visited faces to false
    for( int i = 0; i < Stksize; i++ )
        Stkcells[i] = 0;
 
    for( int i = 0; i <= count; i++ )
        trackcells[i] = 0;
 
    return MB_SUCCESS;
}

References create_halffacet(), moab::error(), ErrorCode, fid_from_halfacet(), find_match_in_array(), moab::Core::get_connectivity(), get_index_in_lmap(), moab::ID_FROM_HANDLE(), moab::index, lConnMap3D, mb, MB_CHK_ERR, MB_SET_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps3D::num_verts_in_cell, sibhfs, Stkcells, trackcells, moab::Core::type_from_handle(), moab::HalfFacetRep::LocalMaps3D::v2hf, and moab::HalfFacetRep::LocalMaps3D::v2hf_num.

Referenced by determine_incident_halffaces().

another_halfedge()

ErrorCode moab::HalfFacetRep::another_halfedge ( EntityHandle  vid, EntityHandle  he_fid, int  he_lid, EntityHandle *  he2_fid, int *  he2_lid  )

protected

Obtains another half-edge belonging to the same face as the input half-edge.

It uses the local maps to find another half-edge that is either incident or outgoing depending on vid and input half-edge

Definition at line 1473 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityType ftype = mb->type_from_handle( he_fid );
    int nepf         = lConnMap2D[ftype - 2].num_verts_in_face;
 
    const EntityHandle* conn;
    error = mb->get_connectivity( he_fid, conn, nepf, true );
    MB_CHK_ERR( error );
 
    *he2_fid = he_fid;
    if( conn[he_lid] == vid )
        *he2_lid = lConnMap2D[ftype - 2].prev[he_lid];
    else
        *he2_lid = lConnMap2D[ftype - 2].next[he_lid];
 
    return MB_SUCCESS;
}

References moab::error(), ErrorCode, moab::Core::get_connectivity(), lConnMap2D, mb, MB_CHK_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps2D::next, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, moab::HalfFacetRep::LocalMaps2D::prev, and moab::Core::type_from_handle().

Referenced by collect_and_compare(), gather_halfedges(), get_up_adjacencies_vert_2d(), and mark_halfedges().

check_mixed_entity_type()

bool moab::HalfFacetRep::check_mixed_entity_type

(

)

Definition at line 131 of file HalfFacetRep.cpp.

{
    if( !chk_mixed )
    {
        chk_mixed = true;
 
        ErrorCode error;
        Range felems, celems;
 
        error = mb->get_entities_by_dimension( this->_rset, 2, felems );
        MB_CHK_ERR( error );
 
        if( felems.size() )
        {
            Range tris, quad, poly;
            tris = felems.subset_by_type( MBTRI );
            quad = felems.subset_by_type( MBQUAD );
            poly = felems.subset_by_type( MBPOLYGON );
            if( ( tris.size() && quad.size() ) || ( tris.size() && poly.size() ) || ( quad.size() && poly.size() ) )
                is_mixed = true;
            if( poly.size() ) is_mixed = true;
 
            if( is_mixed ) return is_mixed;
        }
 
        error = mb->get_entities_by_dimension( this->_rset, 3, celems );
        MB_CHK_ERR( error );
        if( celems.size() )
        {
            Range tet, pyr, prism, hex, polyhed;
            tet     = celems.subset_by_type( MBTET );
            pyr     = celems.subset_by_type( MBPYRAMID );
            prism   = celems.subset_by_type( MBPRISM );
            hex     = celems.subset_by_type( MBHEX );
            polyhed = celems.subset_by_type( MBPOLYHEDRON );
            if( ( tet.size() && pyr.size() ) || ( tet.size() && prism.size() ) || ( tet.size() && hex.size() ) ||
                ( tet.size() && polyhed.size() ) || ( pyr.size() && prism.size() ) || ( pyr.size() && hex.size() ) ||
                ( pyr.size() && polyhed.size() ) || ( prism.size() && hex.size() ) ||
                ( prism.size() && polyhed.size() ) || ( hex.size() && polyhed.size() ) )
                is_mixed = true;
 
            if( polyhed.size() ) is_mixed = true;
        }
 
        ScdInterface* scdi = NULL;
        error              = mb->query_interface( scdi );
        MB_CHK_ERR( error );
        if( scdi )
        {
            Range boxes;
            error = scdi->find_boxes( boxes );
            MB_CHK_ERR( error );
 
            if( !boxes.empty() ) is_mixed = true;
        }
    }
    return is_mixed;
}

References _rset, chk_mixed, moab::Range::empty(), moab::error(), ErrorCode, moab::ScdInterface::find_boxes(), moab::Core::get_entities_by_dimension(), is_mixed, mb, MB_CHK_ERR, MBHEX, MBPOLYGON, MBPOLYHEDRON, MBPRISM, MBPYRAMID, MBQUAD, MBTET, MBTRI, moab::Interface::query_interface(), moab::Range::size(), and moab::Range::subset_by_type().

Referenced by moab::NestedRefine::initialize().

check_nonmanifold_vertices()

bool moab::HalfFacetRep::check_nonmanifold_vertices	(	EntityType	type,
		EntityHandle	vid
	)

Definition at line 3483 of file HalfFacetRep.cpp.

{
    bool status = false;
    if( type == MBTRI || type == MBQUAD )
    {
        HFacet hf = v2he[ID_FROM_HANDLE( vid ) - 1];
        if( hf == 0 && ( v2hes.find( vid ) != v2hes.end() ) ) status = true;
    }
    else if( type == MBTET || type == MBHEX )
    {
        HFacet hf = v2hf[ID_FROM_HANDLE( vid ) - 1];
        if( hf == 0 && ( v2hfs.find( vid ) != v2hfs.end() ) ) status = true;
    }
    else
        MB_SET_ERR( MB_FAILURE, "Requesting non-manifold vertex checks for either (1) 1D mesh or "
                                "(2) not-implemented entity types" );
 
    return status;
}

References moab::ID_FROM_HANDLE(), MB_SET_ERR, MBHEX, MBQUAD, MBTET, MBTRI, v2he, v2hes, v2hf, and v2hfs.

Referenced by moab::NestedRefine::update_global_ahf_3D().

collect_and_compare()

bool moab::HalfFacetRep::collect_and_compare ( const EntityHandle  vid, const EntityHandle *  edg_vert, int *  qsize, int *  count, EntityHandle *  he_fid, int *  he_lid  )

protected

Collect and compare to find a matching half-edge with the given edge connectivity.

Given edge connectivity, compare to an input list of half-edges to find a matching half-edge and add a list of half-edges belonging to the one-ring neighborhood to a queue till it finds a match.

Definition at line 1497 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityType ftype = mb->type_from_handle( *_faces.begin() );
    int nepf         = lConnMap2D[ftype - 2].num_verts_in_face;
 
    bool found    = false;
    int num_qvals = 0, counter = 0;
 
    while( num_qvals < *qsize && counter < MAXSIZE )
    {
        EntityHandle curfid = queue_fid[num_qvals];
        int curlid          = queue_lid[num_qvals];
        num_qvals += 1;
 
        const EntityHandle* conn;
        error = mb->get_connectivity( curfid, conn, nepf, true );
        MB_CHK_ERR( error );
 
        int id = lConnMap2D[ftype - 2].next[curlid];
        if( ( ( conn[curlid] == edg_vert[0] ) && ( conn[id] == edg_vert[1] ) ) ||
            ( ( conn[curlid] == edg_vert[1] ) && ( conn[id] == edg_vert[0] ) ) )
        {
            *he_fid = curfid;
            *he_lid = curlid;
            found   = true;
            break;
        }
 
        bool val = find_match_in_array( curfid, trackfaces, count[0] );
 
        if( val ) continue;
 
        count[0] += 1;
        trackfaces[*count] = curfid;
 
        EntityHandle he2_fid;
        int he2_lid;
        error = another_halfedge( vid, curfid, curlid, &he2_fid, &he2_lid );
        MB_CHK_ERR( error );
        error = get_up_adjacencies_2d( he2_fid, he2_lid, qsize, count );
        MB_CHK_ERR( error );
 
        counter += 1;
    }
    return found;
}

References _faces, another_halfedge(), moab::Range::begin(), moab::error(), ErrorCode, find_match_in_array(), moab::Core::get_connectivity(), get_up_adjacencies_2d(), lConnMap2D, moab::MAXSIZE, mb, MB_CHK_ERR, moab::HalfFacetRep::LocalMaps2D::next, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, queue_fid, queue_lid, trackfaces, and moab::Core::type_from_handle().

Referenced by find_matching_halfedge().

count_subentities()

ErrorCode moab::HalfFacetRep::count_subentities	(	Range &	edges,
		Range &	faces,
		Range &	cells,
		int *	nedges,
		int *	nfaces
	)

Definition at line 665 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    if( edges.size() && !faces.size() && !cells.size() )
    {
        nedges[0] = edges.size();
        nfaces[0] = 0;
    }
    else if( faces.size() && !cells.size() )
    {
        nedges[0] = find_total_edges_2d( faces );
        nfaces[0] = 0;
    }
    else if( cells.size() )
    {
        error = find_total_edges_faces_3d( cells, nedges, nfaces );
        MB_CHK_ERR( error );
    }
    return MB_SUCCESS;
}

References moab::error(), ErrorCode, find_total_edges_2d(), find_total_edges_faces_3d(), MB_CHK_ERR, MB_SUCCESS, and moab::Range::size().

Referenced by moab::NestedRefine::count_subentities().

create_halffacet()

HFacet moab::HalfFacetRep::create_halffacet	(	EntityHandle	handle,
		int	lid
	)

Definition at line 3824 of file HalfFacetRep.cpp.

{
    EntityID fid = ID_FROM_HANDLE( handle );
    return CREATE_HALFFACET( lid, fid );
}

References moab::CREATE_HALFFACET(), and moab::ID_FROM_HANDLE().

Referenced by add_cells_of_single_component(), determine_incident_halfedges(), determine_incident_halfverts(), determine_sibling_halfedges(), determine_sibling_halffaces(), determine_sibling_halfverts(), mark_halfedges(), set_incident_map(), and set_sibling_map().

deinitialize()

ErrorCode moab::HalfFacetRep::deinitialize

(

)

Deinitialize.

Definition at line 305 of file HalfFacetRep.cpp.

{
    return MB_SUCCESS;
}

References MB_SUCCESS.

determine_border_vertices()

ErrorCode moab::HalfFacetRep::determine_border_vertices	(	Range &	cells,
		Tag	isborder
	)

Given a range of cells, tags all border vertices with a true value.

Tag border vertices by using the sibhf_cid map. All vertices on half-faces with no sibling half-faces are considered as border vertices.

Parameters

cells	Range of cells
isborder	A dense tag over all vertices of size 1. Value is true for a border vertex, otherwise is false.

Definition at line 2020 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityHandle start_cell = *cells.begin();
    EntityType ctype        = mb->type_from_handle( *cells.begin() );
    int index               = get_index_in_lmap( start_cell );
    int nvpc                = lConnMap3D[index].num_verts_in_cell;
    int nfpc                = lConnMap3D[index].num_faces_in_cell;
 
    int val = 1;
 
    for( Range::iterator t = cells.begin(); t != cells.end(); ++t )
    {
 
        const EntityHandle* conn;
        error = mb->get_connectivity( *t, conn, nvpc, true );
        MB_CHK_ERR( error );
 
        int cidx = ID_FROM_HANDLE( *t ) - 1;
        for( int i = 0; i < nfpc; ++i )
        {
            HFacet hf            = sibhfs[nfpc * cidx + i];
            EntityHandle sib_cid = fid_from_halfacet( hf, ctype );
 
            if( sib_cid == 0 )
            {
                int nvF = lConnMap3D[index].hf2v_num[i];
 
                for( int j = 0; j < nvF; ++j )
                {
                    int ind = lConnMap3D[index].hf2v[i][j];
                    error   = mb->tag_set_data( isborder, &conn[ind], 1, &val );
                    MB_CHK_ERR( error );
                }
            }
        }
    }
 
    return MB_SUCCESS;
}

References moab::Range::begin(), moab::Range::end(), moab::error(), ErrorCode, fid_from_halfacet(), moab::Core::get_connectivity(), get_index_in_lmap(), moab::HalfFacetRep::LocalMaps3D::hf2v, moab::HalfFacetRep::LocalMaps3D::hf2v_num, moab::ID_FROM_HANDLE(), moab::index, lConnMap3D, mb, MB_CHK_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps3D::num_verts_in_cell, sibhfs, moab::Core::tag_set_data(), and moab::Core::type_from_handle().

determine_incident_halfedges()

ErrorCode moab::HalfFacetRep::determine_incident_halfedges

(

Range &

faces

)

Given a range of faces, determines the incident half-edges and stores them into V2HE_FID, V2HE_LEID tags.

Compute a map between a vertex and an incident half-edge. This map is not always required, but is essential for local neighborhood searching as it acts like an anchor to start the search.

Parameters

faces

Range of faces

Definition at line 1016 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityType ftype = mb->type_from_handle( *faces.begin() );
    int nepf         = lConnMap2D[ftype - 2].num_verts_in_face;
 
    std::vector< char > markEdges( nepf * faces.size(), 0 );
 
    for( Range::iterator it = faces.begin(); it != faces.end(); ++it )
    {
        EntityHandle fid = *it;
        const EntityHandle* conn;
        error = mb->get_connectivity( fid, conn, nepf, true );
        MB_CHK_ERR( error );
 
        for( int i = 0; i < nepf; ++i )
        {
            EntityHandle v = conn[i];
            int vidx       = ID_FROM_HANDLE( v ) - 1;
            HFacet hf      = v2he[vidx];
 
            if( hf == 0 && ( v2hes.empty() || ( v2hes.find( v ) == v2hes.end() ) ) )
            {
                // This is the first time a half-facet is assigned to a vertex.
                HFacet nwhf = 0;
                error       = mark_halfedges( v, fid, i, faces, markEdges, nwhf );
                MB_CHK_ERR( error );
 
                if( nwhf == 0 ) nwhf = create_halffacet( fid, i );
 
                v2he[vidx] = nwhf;
            }
            else if( hf != 0 && !markEdges[nepf * faces.index( fid ) + i] )
            {
                // This is the first time a non-manifold vertex is encountered. Copy the existing he
                // in v2he[v] to the multimap.
                v2hes.insert( std::pair< EntityHandle, HFacet >( v, hf ) );
                HFacet nwhf = 0;
                error       = mark_halfedges( v, fid, i, faces, markEdges, nwhf );
                MB_CHK_ERR( error );
 
                if( nwhf == 0 ) nwhf = create_halffacet( fid, i );
 
                v2hes.insert( std::pair< EntityHandle, HFacet >( v, nwhf ) );
                v2he[vidx] = 0;
            }
            else if( hf == 0 && ( !v2hes.empty() ) && ( v2hes.find( v ) != v2hes.end() ) &&
                     !markEdges[nepf * faces.index( fid ) + i] )
            {
                // This is check if reached if the vertex is non-manifold and has encountered a
                // half-facet to a new component.
                HFacet nwhf = 0;
                error       = mark_halfedges( v, fid, i, faces, markEdges, nwhf );
                MB_CHK_ERR( error );
 
                if( nwhf == 0 ) nwhf = create_halffacet( fid, i );
 
                v2hes.insert( std::pair< EntityHandle, HFacet >( v, nwhf ) );
            }
        }
    }
 
    // error = print_tags(2);
 
    return MB_SUCCESS;
}

References moab::Range::begin(), create_halffacet(), moab::Range::end(), moab::error(), ErrorCode, moab::Core::get_connectivity(), moab::ID_FROM_HANDLE(), moab::Range::index(), lConnMap2D, mark_halfedges(), mb, MB_CHK_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, moab::Range::size(), moab::Core::type_from_handle(), v2he, and v2hes.

Referenced by init_surface().

determine_incident_halffaces()

ErrorCode moab::HalfFacetRep::determine_incident_halffaces

(

Range &

cells

)

Given a range of cells, determines the incident half-faces and stores them into V2HF_CID, V2HF_LFID tags.

Compute a map between a vertex and an incident half-face. This map is not always required, but is essential for local neighborhood searching as it acts like an anchor to start the search.

Parameters

faces

Range of cells

Definition at line 1963 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    int index = get_index_in_lmap( *cells.begin() );
    int nvpc  = lConnMap3D[index].num_verts_in_cell;
 
    std::multimap< EntityHandle, EntityHandle > comps;
    HFacet nwhf;
 
    for( Range::iterator cid = cells.begin(); cid != cells.end(); ++cid )
    {
        EntityHandle cell = *cid;
        const EntityHandle* conn;
        error = mb->get_connectivity( *cid, conn, nvpc, true );
        MB_CHK_ERR( error );
 
        for( int i = 0; i < nvpc; ++i )
        {
            EntityHandle v = conn[i];
            int vidx       = ID_FROM_HANDLE( v ) - 1;
            HFacet hf      = v2hf[vidx];
 
            bool found = find_cell_in_component( v, cell, comps );
 
            if( hf == 0 && !found && ( v2hfs.empty() || ( v2hfs.find( v ) == v2hfs.end() ) ) )
            {
                nwhf  = 0;
                error = add_cells_of_single_component( v, cell, lConnMap3D[index].v2hf[i][0], comps, nwhf );
                MB_CHK_ERR( error );
 
                v2hf[vidx] = nwhf;
            }
            else if( hf != 0 && !found )
            {
                nwhf  = 0;
                error = add_cells_of_single_component( v, cell, lConnMap3D[index].v2hf[i][0], comps, nwhf );
                MB_CHK_ERR( error );
 
                v2hfs.insert( std::pair< EntityHandle, HFacet >( v, hf ) );
                v2hfs.insert( std::pair< EntityHandle, HFacet >( v, nwhf ) );
                v2hf[vidx] = 0;
            }
            else if( hf == 0 && !found && ( !v2hfs.empty() ) && ( v2hfs.find( v ) != v2hfs.end() ) )
            {
                nwhf  = 0;
                error = add_cells_of_single_component( v, cell, lConnMap3D[index].v2hf[i][0], comps, nwhf );
                MB_CHK_ERR( error );
                v2hfs.insert( std::pair< EntityHandle, HFacet >( v, nwhf ) );
            }
        }
    }
 
    // error = print_tags(3);
 
    return MB_SUCCESS;
}

References add_cells_of_single_component(), moab::Range::begin(), moab::Range::end(), moab::error(), ErrorCode, find_cell_in_component(), moab::Core::get_connectivity(), get_index_in_lmap(), moab::ID_FROM_HANDLE(), moab::index, lConnMap3D, mb, MB_CHK_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps3D::num_verts_in_cell, v2hf, and v2hfs.

Referenced by init_volume().

determine_incident_halfverts()

ErrorCode moab::HalfFacetRep::determine_incident_halfverts

(

Range &

edges

)

Given a range of edges, determines the map for incident half-verts and stores them into V2HV_EID, V2HV_LVID tags.

Compute a map between a vertex and an incident half-vertex. This map is not always required, but is essential for local neighborhood searching as it acts like an anchor to start the search.

Parameters

edges

Range of edges

Definition at line 768 of file HalfFacetRep.cpp.

{
    ErrorCode error;
 
    for( Range::iterator e_it = edges.begin(); e_it != edges.end(); ++e_it )
    {
        EntityHandle cur_eid = *e_it;
        const EntityHandle* conn;
        int num_conn = 0;
        error        = mb->get_connectivity( *e_it, conn, num_conn, true );
        MB_CHK_ERR( error );
 
        for( int i = 0; i < 2; ++i )
        {
            EntityHandle v = conn[i];
            int vidx       = ID_FROM_HANDLE( v ) - 1;
 
            HFacet hf        = v2hv[vidx];
            EntityHandle eid = fid_from_halfacet( hf, MBEDGE );
            if( eid == 0 )
            {
                v2hv[vidx] = create_halffacet( cur_eid, i );
            }
        }
    }
 
    return MB_SUCCESS;
}

References moab::Range::begin(), create_halffacet(), moab::Range::end(), moab::error(), ErrorCode, fid_from_halfacet(), moab::Core::get_connectivity(), moab::ID_FROM_HANDLE(), mb, MB_CHK_ERR, MB_SUCCESS, MBEDGE, and v2hv.

Referenced by init_curve(), and moab::NestedRefine::update_ahf_1D().

determine_sibling_halfedges()

ErrorCode moab::HalfFacetRep::determine_sibling_halfedges

(

Range &

faces

)

Given a range of faces, determines the sibling half-edges and stores them into SIBHES_FID, SIBHES_LEID tags.

Compute all sibling half-edges for all half-edges in the given surface. The sibling half-edges is defined in terms of the containing face and the local id of the edge w.r.t that entity. That is, the map consists of two pieces of information: <EntityHandle fid, int leid>

Parameters

faces

Range of faces

Definition at line 889 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityHandle start_face = *faces.begin();
    EntityType ftype        = mb->type_from_handle( start_face );
    int nfaces              = faces.size();
    int nepf                = lConnMap2D[ftype - 2].num_verts_in_face;
 
    // Step 1: Create an index list storing the starting position for each vertex
    int nv = _verts.size();
    std::vector< int > is_index( nv + 1 );
    for( int i = 0; i < nv + 1; i++ )
        is_index[i] = 0;
 
    int index;
 
    for( Range::iterator fid = faces.begin(); fid != faces.end(); ++fid )
    {
        const EntityHandle* conn;
        error = mb->get_connectivity( *fid, conn, nepf, true );
        MB_CHK_ERR( error );
 
        for( int i = 0; i < nepf; i++ )
        {
            index = _verts.index( conn[i] );
            is_index[index + 1] += 1;
        }
    }
    is_index[0] = 0;
 
    for( int i = 0; i < nv; i++ )
        is_index[i + 1] = is_index[i] + is_index[i + 1];
 
    // Step 2: Define two arrays v2hv_eid, v2hv_lvid storing every half-facet on a vertex
    std::vector< EntityHandle > v2nv( nepf * nfaces );
    std::vector< EntityHandle > v2he_map_fid( nepf * nfaces );
    std::vector< int > v2he_map_leid( nepf * nfaces );
 
    for( Range::iterator fid = faces.begin(); fid != faces.end(); ++fid )
    {
        const EntityHandle* conn;
        error = mb->get_connectivity( *fid, conn, nepf, true );
        MB_CHK_ERR( error );
 
        for( int j = 0; j < nepf; j++ )
        {
            int v                      = _verts.index( conn[j] );
            int nidx                   = lConnMap2D[ftype - 2].next[j];
            v2nv[is_index[v]]          = conn[nidx];
            v2he_map_fid[is_index[v]]  = *fid;
            v2he_map_leid[is_index[v]] = j;
            is_index[v] += 1;
        }
    }
 
    for( int i = nv - 2; i >= 0; i-- )
        is_index[i + 1] = is_index[i];
    is_index[0] = 0;
 
    // Step 3: Fill up sibling half-verts map
    for( Range::iterator fid = faces.begin(); fid != faces.end(); ++fid )
    {
        const EntityHandle* conn;
        error = mb->get_connectivity( *fid, conn, nepf, true );
        MB_CHK_ERR( error );
 
        int fidx = ID_FROM_HANDLE( *fid ) - 1;
        for( int k = 0; k < nepf; k++ )
        {
            HFacet hf           = sibhes[nepf * fidx + k];
            EntityHandle sibfid = fid_from_halfacet( hf, ftype );
 
            if( sibfid != 0 ) continue;
 
            int nidx = lConnMap2D[ftype - 2].next[k];
            int v    = _verts.index( conn[k] );
            int vn   = _verts.index( conn[nidx] );
 
            EntityHandle first_fid = *fid;
            int first_leid         = k;
 
            EntityHandle prev_fid = *fid;
            int prev_leid         = k;
 
            for( index = is_index[vn]; index <= is_index[vn + 1] - 1; index++ )
            {
                if( v2nv[index] == conn[k] )
                {
                    EntityHandle cur_fid = v2he_map_fid[index];
                    int cur_leid         = v2he_map_leid[index];
 
                    int pidx                        = ID_FROM_HANDLE( prev_fid ) - 1;
                    sibhes[nepf * pidx + prev_leid] = create_halffacet( cur_fid, cur_leid );
 
                    prev_fid  = cur_fid;
                    prev_leid = cur_leid;
                }
            }
 
            for( index = is_index[v]; index <= is_index[v + 1] - 1; index++ )
            {
                if( ( v2nv[index] == conn[nidx] ) && ( v2he_map_fid[index] != *fid ) )
                {
 
                    EntityHandle cur_fid = v2he_map_fid[index];
                    int cur_leid         = v2he_map_leid[index];
 
                    int pidx                        = ID_FROM_HANDLE( prev_fid ) - 1;
                    sibhes[nepf * pidx + prev_leid] = create_halffacet( cur_fid, cur_leid );
 
                    prev_fid  = cur_fid;
                    prev_leid = cur_leid;
                }
            }
 
            if( prev_fid != first_fid )
            {
 
                int pidx                        = ID_FROM_HANDLE( prev_fid ) - 1;
                sibhes[nepf * pidx + prev_leid] = create_halffacet( first_fid, first_leid );
            }
        }
    }
 
    return MB_SUCCESS;
}

References _verts, moab::Range::begin(), create_halffacet(), moab::Range::end(), moab::error(), ErrorCode, fid_from_halfacet(), moab::Core::get_connectivity(), moab::ID_FROM_HANDLE(), moab::index, moab::Range::index(), lConnMap2D, mb, MB_CHK_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps2D::next, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, sibhes, moab::Range::size(), and moab::Core::type_from_handle().

Referenced by init_surface().

determine_sibling_halffaces()

ErrorCode moab::HalfFacetRep::determine_sibling_halffaces

(

Range &

cells

)

Given a range of cells, determines the sibling half-faces and stores them into SIBHFS_CID, SIBHFS_LFID tags.

Compute all sibling half-faces for all half-faces in the given volume. The sibling half-faces is defined in terms of the containing cell and the local id of the face w.r.t that cell. That is, the map consists of two pieces of information: <EntityHandle cid, int lfid>

Parameters

faces

Range of cells

Definition at line 1820 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityHandle start_cell = *cells.begin();
    EntityType ctype        = mb->type_from_handle( start_cell );
    int index               = get_index_in_lmap( start_cell );
    int nvpc                = lConnMap3D[index].num_verts_in_cell;
    int nfpc                = lConnMap3D[index].num_faces_in_cell;
 
    // Step 1: Create an index list storing the starting position for each vertex
    int nv = _verts.size();
    std::vector< int > is_index( nv + 1 );
    for( int i = 0; i < nv + 1; i++ )
        is_index[i] = 0;
 
    int vindex;
 
    for( Range::iterator cid = cells.begin(); cid != cells.end(); ++cid )
    {
        const EntityHandle* conn;
        error = mb->get_connectivity( *cid, conn, nvpc, true );
        MB_CHK_ERR( error );
 
        for( int i = 0; i < nfpc; ++i )
        {
            int nvF        = lConnMap3D[index].hf2v_num[i];
            EntityHandle v = 0;
            for( int k = 0; k < nvF; k++ )
            {
                int id = lConnMap3D[index].hf2v[i][k];
                if( v <= conn[id] ) v = conn[id];
            }
            vindex = _verts.index( v );
            is_index[vindex + 1] += 1;
        }
    }
    is_index[0] = 0;
 
    for( int i = 0; i < nv; i++ )
        is_index[i + 1] = is_index[i] + is_index[i + 1];
 
    // Step 2: Define four arrays v2hv_eid, v2hv_lvid storing every half-facet on a vertex
    std::vector< EntityHandle > v2oe_v1( is_index[nv] );
    std::vector< EntityHandle > v2oe_v2( is_index[nv] );
    std::vector< EntityHandle > v2hf_map_cid( is_index[nv] );
    std::vector< int > v2hf_map_lfid( is_index[nv] );
 
    for( Range::iterator cid = cells.begin(); cid != cells.end(); ++cid )
    {
        const EntityHandle* conn;
        error = mb->get_connectivity( *cid, conn, nvpc, true );
        MB_CHK_ERR( error );
 
        for( int i = 0; i < nfpc; i++ )
        {
            int nvF = lConnMap3D[index].hf2v_num[i];
            std::vector< EntityHandle > vs( nvF );
            EntityHandle vmax = 0;
            int lv            = -1;
            for( int k = 0; k < nvF; k++ )
            {
                int id = lConnMap3D[index].hf2v[i][k];
                vs[k]  = conn[id];
                if( vmax <= conn[id] )
                {
                    vmax = conn[id];
                    lv   = k;
                }
            }
 
            int nidx = lConnMap2D[nvF - 3].next[lv];
            int pidx = lConnMap2D[nvF - 3].prev[lv];
 
            int v                      = _verts.index( vmax );
            v2oe_v1[is_index[v]]       = vs[nidx];
            v2oe_v2[is_index[v]]       = vs[pidx];
            v2hf_map_cid[is_index[v]]  = *cid;
            v2hf_map_lfid[is_index[v]] = i;
            is_index[v] += 1;
        }
    }
 
    for( int i = nv - 2; i >= 0; i-- )
        is_index[i + 1] = is_index[i];
    is_index[0] = 0;
 
    // Step 3: Fill up sibling half-verts map
    for( Range::iterator cid = cells.begin(); cid != cells.end(); ++cid )
    {
        const EntityHandle* conn;
        error = mb->get_connectivity( *cid, conn, nvpc, true );
        MB_CHK_ERR( error );
 
        int cidx = ID_FROM_HANDLE( *cid ) - 1;
        for( int i = 0; i < nfpc; i++ )
        {
            HFacet hf           = sibhfs[nfpc * cidx + i];
            EntityHandle sibcid = fid_from_halfacet( hf, ctype );
 
            if( sibcid != 0 ) continue;
 
            int nvF = lConnMap3D[index].hf2v_num[i];
            std::vector< EntityHandle > vs( nvF );
            EntityHandle vmax = 0;
            int lv            = -1;
            for( int k = 0; k < nvF; k++ )
            {
                int id = lConnMap3D[index].hf2v[i][k];
                vs[k]  = conn[id];
                if( vmax <= conn[id] )
                {
                    vmax = conn[id];
                    lv   = k;
                }
            }
            if( lv < 0 ) MB_SET_ERR( MB_FAILURE, "did not find local vertex " );
            int nidx = lConnMap2D[nvF - 3].next[lv];
            int pidx = lConnMap2D[nvF - 3].prev[lv];
 
            int v           = _verts.index( vmax );
            EntityHandle v1 = vs[pidx];
            EntityHandle v2 = vs[nidx];
 
            for( int ind = is_index[v]; ind <= is_index[v + 1] - 1; ind++ )
            {
                if( ( v2oe_v1[ind] == v1 ) && ( v2oe_v2[ind] == v2 ) )
                {
                    // Map to opposite hf
                    EntityHandle cur_cid = v2hf_map_cid[ind];
                    int cur_lfid         = v2hf_map_lfid[ind];
 
                    sibhfs[nfpc * cidx + i] = create_halffacet( cur_cid, cur_lfid );
 
                    int scidx                       = ID_FROM_HANDLE( cur_cid ) - 1;
                    sibhfs[nfpc * scidx + cur_lfid] = create_halffacet( *cid, i );
                }
            }
        }
    }
 
    return MB_SUCCESS;
}

References _verts, moab::Range::begin(), create_halffacet(), moab::Range::end(), moab::error(), ErrorCode, fid_from_halfacet(), moab::Core::get_connectivity(), get_index_in_lmap(), moab::HalfFacetRep::LocalMaps3D::hf2v, moab::HalfFacetRep::LocalMaps3D::hf2v_num, moab::ID_FROM_HANDLE(), moab::index, moab::Range::index(), lConnMap2D, lConnMap3D, mb, MB_CHK_ERR, MB_SET_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps2D::next, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps3D::num_verts_in_cell, moab::HalfFacetRep::LocalMaps2D::prev, sibhfs, moab::Range::size(), and moab::Core::type_from_handle().

Referenced by init_volume().

determine_sibling_halfverts()

ErrorCode moab::HalfFacetRep::determine_sibling_halfverts	(	Range &	verts,
		Range &	edges
	)

Given a range of edges, determines the map for sibling half-verts and stores them into SIBHVS_EID, SIBHVS_LVID tags.

Compute all sibling half-vertices for all half-vertices in the given curve. The sibling half-verts is defined in terms of the containing edge and the local id of the vertex w.r.t that edge. That is, the map consists of two pieces of information: <EntityHandle eid, int lvid>

Parameters

edges

Range of edges.

Definition at line 689 of file HalfFacetRep.cpp.

{
    ErrorCode error;
 
    // Step 1: Create an index list storing the starting position for each vertex
    int nv = verts.size();
    std::vector< int > is_index( nv + 1 );
    for( int i = 0; i < nv + 1; i++ )
        is_index[i] = 0;
 
    for( Range::iterator eid = edges.begin(); eid != edges.end(); ++eid )
    {
        const EntityHandle* conn;
        int num_conn = 0;
        error        = mb->get_connectivity( *eid, conn, num_conn, true );
        MB_CHK_ERR( error );
 
        int index = verts.index( conn[0] );
        is_index[index + 1] += 1;
        index = verts.index( conn[1] );
        is_index[index + 1] += 1;
    }
    is_index[0] = 0;
 
    for( int i = 0; i < nv; i++ )
        is_index[i + 1] = is_index[i] + is_index[i + 1];
 
    // Step 2: Define two arrays v2hv_eid, v2hv_lvid storing every half-facet on a vertex
    std::vector< EntityHandle > v2hv_map_eid( 2 * edges.size() );
    std::vector< int > v2hv_map_lvid( 2 * edges.size() );
 
    for( Range::iterator eid = edges.begin(); eid != edges.end(); ++eid )
    {
        const EntityHandle* conn;
        int num_conn = 0;
        error        = mb->get_connectivity( *eid, conn, num_conn, true );
        MB_CHK_ERR( error );
 
        for( int j = 0; j < 2; j++ )
        {
            int v                      = verts.index( conn[j] );
            v2hv_map_eid[is_index[v]]  = *eid;
            v2hv_map_lvid[is_index[v]] = j;
            is_index[v] += 1;
        }
    }
 
    for( int i = nv - 2; i >= 0; i-- )
        is_index[i + 1] = is_index[i];
    is_index[0] = 0;
 
    // Step 3: Fill up sibling half-verts map
    for( Range::iterator vid = verts.begin(); vid != verts.end(); ++vid )
    {
        int v    = verts.index( *vid );
        int last = is_index[v + 1] - 1;
        if( last > is_index[v] )
        {
            EntityHandle prev_eid = v2hv_map_eid[last];
            int prev_lvid         = v2hv_map_lvid[last];
 
            for( int i = is_index[v]; i <= last; i++ )
            {
                EntityHandle cur_eid = v2hv_map_eid[i];
                int cur_lvid         = v2hv_map_lvid[i];
 
                int pidx                     = ID_FROM_HANDLE( prev_eid ) - 1;
                sibhvs[2 * pidx + prev_lvid] = create_halffacet( cur_eid, cur_lvid );
 
                prev_eid  = cur_eid;
                prev_lvid = cur_lvid;
            }
        }
    }
 
    return MB_SUCCESS;
}

References moab::Range::begin(), create_halffacet(), moab::Range::end(), moab::error(), ErrorCode, moab::Core::get_connectivity(), moab::ID_FROM_HANDLE(), moab::index, moab::Range::index(), mb, MB_CHK_ERR, MB_SUCCESS, sibhvs, and moab::Range::size().

Referenced by init_curve(), and moab::NestedRefine::update_ahf_1D().

fid_from_halfacet()

EntityHandle moab::HalfFacetRep::fid_from_halfacet	(	const HFacet	facet,
		EntityType	type
	)

Definition at line 3830 of file HalfFacetRep.cpp.

{
    EntityID id         = FID_FROM_HALFFACET( facet );
    EntityHandle handle = 0;
    if( id == 0 ) return handle;
 
    ErrorCode error = mb->handle_from_id( type, id, handle );
    MB_CHK_ERR( error );
    return handle;
}

References moab::error(), ErrorCode, moab::FID_FROM_HALFFACET(), moab::Core::handle_from_id(), mb, and MB_CHK_ERR.

Referenced by add_cells_of_single_component(), determine_border_vertices(), determine_incident_halfverts(), determine_sibling_halfedges(), determine_sibling_halffaces(), find_matching_halfedge(), find_matching_halfface(), find_matching_implicit_edge_in_cell(), get_half_facet_in_comp(), get_incident_map(), get_neighbor_adjacencies_1d(), get_neighbor_adjacencies_3d(), get_sibling_map(), get_up_adjacencies_1d(), get_up_adjacencies_2d(), get_up_adjacencies_edg_3d(), get_up_adjacencies_edg_3d_comp(), get_up_adjacencies_face_3d(), get_up_adjacencies_vert_2d(), get_up_adjacencies_vert_3d(), mark_halfedges(), and print_tags().

find_cell_in_component()

bool moab::HalfFacetRep::find_cell_in_component ( EntityHandle  vid, EntityHandle  cell, std::multimap< EntityHandle, EntityHandle > &  comps  )

protected

Definition at line 2148 of file HalfFacetRep.cpp.

{
    bool found = false;
 
    if( comps.empty() ) return found;
 
    std::pair< std::multimap< EntityHandle, EntityHandle >::iterator,
               std::multimap< EntityHandle, EntityHandle >::iterator >
        rit;
 
    rit = comps.equal_range( vid );
 
    for( std::multimap< EntityHandle, EntityHandle >::iterator it = rit.first; it != rit.second; ++it )
    {
        if( it->second == cell )
        {
            found = true;
            break;
        }
    }
 
    return found;
}

Referenced by determine_incident_halffaces().

find_match_in_array()

bool moab::HalfFacetRep::find_match_in_array ( EntityHandle  ent, EntityHandle *  ent_list, int  count, bool  get_index = false, int *  index = NULL  )

protected

Definition at line 3261 of file HalfFacetRep.cpp.

{
    bool found = false;
    for( int i = 0; i <= count; i++ )
    {
        if( ent == ent_list[i] )
        {
            found = true;
            if( get_index ) *index = i;
            break;
        }
    }
 
    return found;
}

References moab::index.

Referenced by add_cells_of_single_component(), collect_and_compare(), find_matching_halfface(), find_matching_implicit_edge_in_cell(), get_up_adjacencies_2d(), get_up_adjacencies_edg_3d(), get_up_adjacencies_edg_3d_comp(), get_up_adjacencies_vert_2d(), get_up_adjacencies_vert_3d(), and mark_halfedges().

find_matching_halfedge()

bool moab::HalfFacetRep::find_matching_halfedge ( EntityHandle  eid, EntityHandle *  hefid, int *  helid  )

protected

Given an edge, finds a matching half-edge in the surface.

Given an edge eid, it first collects few half-edges belonging to one-ring neighborhood of the starting vertex of the given edge, and then simultaneously searches and adds to the local list of half-edges for searching, till it finds a matching half-edge.

Parameters

eid	EntityHandle of the query edge
hefid,helid	Returns the matching half-edge corresponding to the query edge.

Definition at line 1393 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityType ftype = mb->type_from_handle( *_faces.begin() );
 
    const EntityHandle* conn;
    int num_conn = 0;
    error        = mb->get_connectivity( eid, conn, num_conn, true );
    MB_CHK_ERR( error );
 
    EntityHandle vid = conn[0];
    int vidx         = ID_FROM_HANDLE( conn[0] ) - 1;
    HFacet hf        = v2he[vidx];
 
    if( hf == 0 )
    {
        vidx = ID_FROM_HANDLE( conn[1] ) - 1;
        hf   = v2he[vidx];
 
        if( hf == 0 )  // The edge is either a dangling edge or attached to two non-manifold
                       // vertices
            return MB_SUCCESS;
 
        vid = conn[1];
    }
 
    EntityHandle fid = fid_from_halfacet( hf, ftype );
    int lid          = lid_from_halffacet( hf );
 
    bool found = false;
    int qsize = 0, count = -1;
 
    error = gather_halfedges( vid, fid, lid, &qsize, &count );
    MB_CHK_ERR( error );
 
    found = collect_and_compare( vid, conn, &qsize, &count, hefid, helid );
    MB_CHK_ERR( error );
 
    // Change the visited faces to false
    for( int i = 0; i < qsize; i++ )
    {
        queue_fid[i] = 0;
        queue_lid[i] = 0;
    }
 
    for( int i = 0; i <= count; i++ )
        trackfaces[i] = 0;
 
    return found;
}

References _faces, moab::Range::begin(), collect_and_compare(), moab::error(), ErrorCode, fid_from_halfacet(), gather_halfedges(), moab::Core::get_connectivity(), moab::ID_FROM_HANDLE(), lid_from_halffacet(), mb, MB_CHK_ERR, MB_SUCCESS, queue_fid, queue_lid, trackfaces, moab::Core::type_from_handle(), and v2he.

Referenced by get_up_adjacencies_2d().

find_matching_halfface()

bool moab::HalfFacetRep::find_matching_halfface ( EntityHandle  fid, EntityHandle *  cid, int *  leid  )

protected

Given a face, finds a matching local face in an incident cell.

Find a local face with the same connectivity as the input face, belonging to an incident cell.

Parameters

fid	EntityHandle of the face
cid	Returns EntityHandle of the incident cell
lfid	Returns the local id of the face corresponding to the input face w.r.t the incident cell.

Definition at line 2903 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityHandle start_cell = *_cells.begin();
    EntityType ctype        = mb->type_from_handle( start_cell );
    int index               = get_index_in_lmap( start_cell );
    int nvpc                = lConnMap3D[index].num_verts_in_cell;
    int nfpc                = lConnMap3D[index].num_faces_in_cell;
    EntityType ftype        = mb->type_from_handle( fid );
    int nvF                 = lConnMap2D[ftype - 2].num_verts_in_face;
 
    const EntityHandle* fid_verts;
    error = mb->get_connectivity( fid, fid_verts, nvF, true );
    MB_CHK_ERR( error );
 
    std::vector< EntityHandle > start_cells;
    int vidx, locfv0 = -1;
    HFacet hf = 0;
 
    for( int i = 0; i < nvF; i++ )
    {
        vidx = ID_FROM_HANDLE( fid_verts[i] ) - 1;
        hf   = v2hf[vidx];
        if( hf != 0 )
        {
            start_cells.push_back( fid_from_halfacet( hf, ctype ) );
            locfv0 = i;
            break;
        }
        else if( hf == 0 && v2hfs.find( fid_verts[i] ) != v2hfs.end() )
        {
            std::pair< std::multimap< EntityHandle, HFacet >::iterator,
                       std::multimap< EntityHandle, HFacet >::iterator >
                it_hfs;
            it_hfs = v2hfs.equal_range( fid_verts[i] );
 
            for( std::multimap< EntityHandle, HFacet >::iterator it = it_hfs.first; it != it_hfs.second; ++it )
            {
                start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
            }
            locfv0 = i;
            break;
        }
    }
 
    if( start_cells.empty() ) return false;
 
    EntityHandle cur_cid;
    bool found = false;
 
    int Stksize = 0, count = -1;
 
    for( int i = 0; i < (int)start_cells.size(); i++ )
        Stkcells[i] = start_cells[i];
 
    Stksize = start_cells.size() - 1;
 
    while( Stksize >= 0 )
    {
        cur_cid = Stkcells[Stksize];
        Stksize -= 1;
        count += 1;
        trackcells[count] = cur_cid;
 
        const EntityHandle* conn;
        error = mb->get_connectivity( cur_cid, conn, nvpc, true );
        MB_CHK_ERR( error );
 
        int lv[4] = { -1, -1, -1, -1 };
        int cnt   = 0;
        for( int i = 0; i < nvpc; i++ )
        {
            for( int j = 0; j < nvF; j++ )
                if( conn[i] == fid_verts[j] )
                {
                    lv[j] = i;
                    cnt += 1;
                }
        }
        if( cnt == nvF )  // All face verts are part of the cell
        {
            found         = true;
            int nhf_thisv = lConnMap3D[index].v2hf_num[lv[locfv0]];
            int lfid      = -1;
            for( int i = 0; i < nhf_thisv; ++i )
            {
                lfid     = lConnMap3D[index].v2hf[lv[locfv0]][i];
                int lcnt = 0;
                for( int j = 0; j < nvF; ++j )
                {
                    for( int k = 0; k < nvF; ++k )
                    {
                        if( lv[k] == lConnMap3D[index].hf2v[lfid][j] ) lcnt += 1;
                    }
                }
                if( lcnt == nvF ) break;
            }
            cid[0] = cur_cid;
            lid[0] = lfid;
 
            break;
        }
        else
        {
            // Add other cells that are incident on fid_verts[0]
            if( locfv0 < 0 || lv[locfv0] < 0 ) MB_SET_ERR( MB_FAILURE, "did not find local vertex " );
            int nhf_thisv = lConnMap3D[index].v2hf_num[lv[locfv0]];
            int cidx      = ID_FROM_HANDLE( cur_cid ) - 1;
 
            // Add new cells into the stack
            EntityHandle ngb;
            for( int i = 0; i < nhf_thisv; ++i )
            {
                int ind = lConnMap3D[index].v2hf[lv[locfv0]][i];
                hf      = sibhfs[nfpc * cidx + ind];
                ngb     = fid_from_halfacet( hf, ctype );
 
                if( ngb )
                {
 
                    bool found_ent = find_match_in_array( ngb, trackcells, count );
 
                    if( !found_ent )
                    {
                        Stksize += 1;
                        Stkcells[Stksize] = ngb;
                    }
                }
            }
        }
    }
 
    // Change the visited faces to false
    for( int i = 0; i < Stksize; i++ )
        Stkcells[i] = 0;
 
    for( int i = 0; i <= count; i++ )
        trackcells[i] = 0;
 
    return found;
}

References _cells, moab::Range::begin(), moab::error(), ErrorCode, fid_from_halfacet(), find_match_in_array(), moab::Core::get_connectivity(), get_index_in_lmap(), moab::ID_FROM_HANDLE(), moab::index, lConnMap2D, lConnMap3D, mb, MB_CHK_ERR, MB_SET_ERR, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps3D::num_verts_in_cell, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, sibhfs, Stkcells, trackcells, moab::Core::type_from_handle(), moab::HalfFacetRep::LocalMaps3D::v2hf, v2hf, moab::HalfFacetRep::LocalMaps3D::v2hf_num, and v2hfs.

Referenced by get_up_adjacencies_face_3d().

find_matching_implicit_edge_in_cell()

bool moab::HalfFacetRep::find_matching_implicit_edge_in_cell ( EntityHandle  eid, std::vector< EntityHandle > &  cid, std::vector< int > &  leid  )

protected

Given an edge, finds a matching local edge in an incident cell.

Find a local edge with the same connectivity as the input edge, belonging to an incident cell.

Parameters

eid	EntityHandle of the edge
cid	Returns EntityHandle of the incident cell
leid	Returns the local id of the edge corresponding to the input edge w.r.t the incident cell.

Definition at line 2765 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityType ctype        = mb->type_from_handle( *_cells.begin() );
    EntityHandle start_cell = *_cells.begin();
    int index               = get_index_in_lmap( start_cell );
    int nvpc                = lConnMap3D[index].num_verts_in_cell;
    int nfpc                = lConnMap3D[index].num_faces_in_cell;
 
    // Find the edge vertices
    const EntityHandle* econn;
    int num_conn = 0;
    error        = mb->get_connectivity( eid, econn, num_conn, true );
    MB_CHK_ERR( error );
 
    EntityHandle v_start = econn[0], v_end = econn[1];
    int v1idx = ID_FROM_HANDLE( v_start ) - 1;
    int v2idx = ID_FROM_HANDLE( v_end ) - 1;
 
    // Find an incident cell to v_start
    std::vector< EntityHandle > start_cells;
    HFacet hf1 = v2hf[v1idx];
    HFacet hf2 = v2hf[v2idx];
 
    int ncomps1 = 0, ncomps2 = 0, ncomp;
    if( hf1 == 0 && !v2hfs.empty() )
    {
        std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
            it_hes;
        it_hes = v2hfs.equal_range( v_start );
 
        for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
        {
            start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
            ncomps1 += 1;
        }
    }
    else if( hf1 != 0 )
    {
        start_cells.push_back( fid_from_halfacet( hf1, ctype ) );
        ncomps1 += 1;
    }
 
    if( hf2 == 0 && !v2hfs.empty() )
    {
        std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
            it_hes;
        it_hes = v2hfs.equal_range( v_end );
 
        for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
        {
            start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
            ncomps2 += 1;
        }
    }
    else if( hf2 != 0 )
    {
        start_cells.push_back( fid_from_halfacet( hf2, ctype ) );
        ncomps2 += 1;
    }
 
    ncomp = std::min( ncomps1, ncomps2 );
 
    bool found = false;
    if( start_cells.empty() ) return found;
 
    for( int i = 0; i < (int)start_cells.size(); i++ )
        cellq[i] = start_cells[i];
 
    int qsize     = start_cells.size();
    int num_qvals = 0;
 
    while( num_qvals < qsize )
    {
        EntityHandle cell_id = cellq[num_qvals];
        num_qvals += 1;
 
        const EntityHandle* conn;
        error = mb->get_connectivity( cell_id, conn, nvpc, true );
        MB_CHK_ERR( error );
 
        int lv0 = -1, lv1 = -1, lv = -1;
 
        // locate v_origin in poped out tet, check if v_end is in
        for( int i = 0; i < nvpc; i++ )
        {
            if( v_start == conn[i] )
            {
                lv0 = i;
                lv  = lv0;
            }
            else if( v_end == conn[i] )
            {
                lv1 = i;
                lv  = lv1;
            }
        }
 
        if( ( lv0 >= 0 ) && ( lv1 >= 0 ) )
        {
            found = true;
            cid.push_back( cell_id );
            leid.push_back( lConnMap3D[index].lookup_leids[lv0][lv1] );
 
            if( (int)cid.size() == ncomp ) break;
        }
 
        // push back new found unchecked incident tets of v_start
        int cidx      = ID_FROM_HANDLE( cell_id ) - 1;
        int nhf_thisv = lConnMap3D[index].v2hf_num[lv];
        if( lv < 0 ) MB_SET_ERR( MB_FAILURE, "did not find local vertex " );
        for( int i = 0; i < nhf_thisv; i++ )
        {
            int ind          = lConnMap3D[index].v2hf[lv][i];
            HFacet hf        = sibhfs[nfpc * cidx + ind];
            EntityHandle ngb = fid_from_halfacet( hf, ctype );
 
            if( ngb )
            {
                bool found_ent = find_match_in_array( ngb, &cellq[0], qsize - 1 );
 
                if( !found_ent )
                {
                    cellq[qsize] = ngb;
                    qsize += 1;
                }
            }
        }
    }
 
    for( int i = 0; i < qsize; i++ )
        cellq[i] = 0;
 
    return found;
}

References _cells, moab::Range::begin(), cellq, moab::error(), ErrorCode, fid_from_halfacet(), find_match_in_array(), moab::Core::get_connectivity(), get_index_in_lmap(), moab::ID_FROM_HANDLE(), moab::index, lConnMap3D, mb, MB_CHK_ERR, MB_SET_ERR, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps3D::num_verts_in_cell, sibhfs, moab::Core::type_from_handle(), moab::HalfFacetRep::LocalMaps3D::v2hf, v2hf, moab::HalfFacetRep::LocalMaps3D::v2hf_num, and v2hfs.

find_total_edges_2d()

int moab::HalfFacetRep::find_total_edges_2d

(

Range &

faces

)

Given a range of faces, finds the total number of edges.

Definition at line 1635 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityType ftype = mb->type_from_handle( *faces.begin() );
    int nepf         = lConnMap2D[ftype - 2].num_verts_in_face;
    int nfaces       = faces.size();
 
    int total_edges = nepf * nfaces;
 
    std::vector< int > trackF( total_edges, 0 );
    std::vector< EntityHandle > adj_fids;
    std::vector< int > adj_lids;
 
    for( Range::iterator f = faces.begin(); f != faces.end(); ++f )
    {
        for( int l = 0; l < nepf; l++ )
        {
 
            adj_fids.clear();
            adj_lids.clear();
 
            int id = nepf * ( faces.index( *f ) ) + l;
            if( !trackF[id] )
            {
                error = get_up_adjacencies_2d( *f, l, false, adj_fids, &adj_lids );
                MB_CHK_ERR( error );
 
                total_edges -= adj_fids.size();
 
                for( int i = 0; i < (int)adj_fids.size(); i++ )
                    trackF[nepf * ( faces.index( adj_fids[i] ) ) + adj_lids[i]] = 1;
            };
        };
    };
 
    return total_edges;
}

References moab::Range::begin(), moab::Range::end(), moab::error(), ErrorCode, get_up_adjacencies_2d(), moab::Range::index(), lConnMap2D, mb, MB_CHK_ERR, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, moab::Range::size(), and moab::Core::type_from_handle().

Referenced by count_subentities().

find_total_edges_faces_3d()

ErrorCode moab::HalfFacetRep::find_total_edges_faces_3d	(	const Range &	cells,
		int *	nedges,
		int *	nfaces
	)

Definition at line 3199 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    int index       = get_index_in_lmap( *cells.begin() );
    int nepc        = lConnMap3D[index].num_edges_in_cell;
    int nfpc        = lConnMap3D[index].num_faces_in_cell;
    int ncells      = cells.size();
    int total_edges = nepc * ncells;
    int total_faces = nfpc * ncells;
 
    std::vector< int > trackE( total_edges, 0 );
    std::vector< int > trackF( total_faces, 0 );
 
    std::vector< EntityHandle > inc_cids, sib_cids;
    std::vector< int > inc_leids, sib_lfids;
 
    for( Range::iterator it = cells.begin(); it != cells.end(); ++it )
    {
        // Count edges
        for( int i = 0; i < nepc; i++ )
        {
            inc_cids.clear();
            inc_leids.clear();
 
            int id = nepc * ( cells.index( *it ) ) + i;
            if( !trackE[id] )
            {
                error = get_up_adjacencies_edg_3d( *it, i, inc_cids, &inc_leids );
                MB_CHK_ERR( error );
 
                total_edges -= inc_cids.size() - 1;
                for( int j = 0; j < (int)inc_cids.size(); j++ )
                    trackE[nepc * ( cells.index( inc_cids[j] ) ) + inc_leids[j]] = 1;
            }
        }
 
        // Count faces
        for( int i = 0; i < nfpc; i++ )
        {
            sib_cids.clear();
            sib_lfids.clear();
 
            int id = nfpc * ( cells.index( *it ) ) + i;
            if( !trackF[id] )
            {
                error = get_up_adjacencies_face_3d( *it, i, sib_cids, &sib_lfids );
                MB_CHK_ERR( error );
 
                if( sib_cids.size() == 1 ) continue;
 
                total_faces -= sib_cids.size() - 1;
                trackF[nfpc * ( cells.index( sib_cids[1] ) ) + sib_lfids[1]] = 1;
            }
        }
    }
 
    nedges[0] = total_edges;
    nfaces[0] = total_faces;
 
    return MB_SUCCESS;
}

References moab::Range::begin(), moab::Range::end(), moab::error(), ErrorCode, get_index_in_lmap(), get_up_adjacencies_edg_3d(), get_up_adjacencies_face_3d(), moab::index, moab::Range::index(), lConnMap3D, MB_CHK_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps3D::num_edges_in_cell, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, and moab::Range::size().

Referenced by count_subentities().

gather_halfedges()

ErrorCode moab::HalfFacetRep::gather_halfedges ( EntityHandle  vid, EntityHandle  he_fid, int  he_lid, int *  qsize, int *  count  )

protected

Gather half-edges to a queue of half-edges.

Given a vertex vid, and a half-edge <he_fid,he_lid>, add another half-edge in the same face sharing the vertex

Definition at line 1444 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityHandle he2_fid = 0;
    int he2_lid          = 0;
 
    error = another_halfedge( vid, he_fid, he_lid, &he2_fid, &he2_lid );
    MB_CHK_ERR( error );
 
    queue_fid[*qsize] = he_fid;
    queue_lid[*qsize] = he_lid;
    *qsize += 1;
 
    queue_fid[*qsize] = he2_fid;
    queue_lid[*qsize] = he2_lid;
    *qsize += 1;
 
    *count += 1;
    trackfaces[*count] = he_fid;
 
    error = get_up_adjacencies_2d( he_fid, he_lid, qsize, count );
    MB_CHK_ERR( error );
    error = get_up_adjacencies_2d( he2_fid, he2_lid, qsize, count );
    MB_CHK_ERR( error );
 
    return MB_SUCCESS;
}

References another_halfedge(), moab::error(), ErrorCode, get_up_adjacencies_2d(), MB_CHK_ERR, MB_SUCCESS, queue_fid, queue_lid, and trackfaces.

Referenced by find_matching_halfedge(), get_up_adjacencies_vert_2d(), and mark_halfedges().

get_adjacencies()

ErrorCode moab::HalfFacetRep::get_adjacencies	(	const EntityHandle	source_entity,
		const unsigned int	target_dimension,
		std::vector< EntityHandle > &	target_entities
	)

Get the adjacencies associated with an entity.

Given an entity of dimension d, gather all the adjacent D dimensional entities where D >, = , < d .

Parameters

source_entity	EntityHandle to which adjacent entities have to be found.
target_dimension	Int Dimension of the desired adjacent entities.
target_entities	Vector in which the adjacent EntityHandle are returned.

Definition at line 527 of file HalfFacetRep.cpp.

{
 
    ErrorCode error;
 
    unsigned int source_dimension = mb->dimension_from_handle( source_entity );
    assert( ( source_dimension <= target_dimension ) || ( source_dimension > target_dimension ) );
 
    if( mInitAHFmaps == false )
    {
        error = initialize();
        MB_CHK_ERR( error );
    }
 
    int mindex       = get_index_for_meshtype( thismeshtype );
    int adj_possible = adjMatrix[mindex].val[source_dimension][target_dimension];
 
    if( adj_possible )
    {
        if( source_dimension < target_dimension )
        {
            error = get_up_adjacencies( source_entity, target_dimension, target_entities );
            MB_CHK_ERR( error );
        }
        else if( source_dimension == target_dimension )
        {
            error = get_neighbor_adjacencies( source_entity, target_entities );
            MB_CHK_ERR( error );
        }
        else
        {
            error = get_down_adjacencies( source_entity, target_dimension, target_entities );
            MB_CHK_ERR( error );
        }
    }
    else
        return MB_SUCCESS;
 
    return MB_SUCCESS;
}

References adjMatrix, moab::Core::dimension_from_handle(), moab::error(), ErrorCode, get_down_adjacencies(), get_index_for_meshtype(), get_neighbor_adjacencies(), get_up_adjacencies(), initialize(), mb, MB_CHK_ERR, MB_SUCCESS, mInitAHFmaps, thismeshtype, and moab::HalfFacetRep::adj_matrix::val.

Referenced by moab::NestedRefine::get_adjacencies().

get_down_adjacencies()

ErrorCode moab::HalfFacetRep::get_down_adjacencies	(	EntityHandle	ent,
		int	out_dim,
		std::vector< EntityHandle > &	adjents
	)

Get the downward adjacent entities connected with an entity.

Given an entity of dimension d, gather all the d-1 dimensional entities.

Parameters

ent	EntityHandle to which neighbor entities have to be found.
out_dim	Dimension of the desired downward adjacency.
adjents	Vector in which the neighbor entities are returned.

Definition at line 641 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    int in_dim = mb->dimension_from_handle( ent );
    assert( ( in_dim >= 2 && in_dim <= 3 ) && ( out_dim < in_dim ) );
 
    if( ( in_dim == 2 ) && ( out_dim == 1 ) )
    {
        error = get_down_adjacencies_2d( ent, adjents );
        MB_CHK_ERR( error );
    }
    else if( ( in_dim == 3 ) && ( out_dim == 1 ) )
    {
        error = get_down_adjacencies_edg_3d( ent, adjents );
        MB_CHK_ERR( error );
    }
    else if( ( in_dim == 3 ) && ( out_dim == 2 ) )
    {
        error = get_down_adjacencies_face_3d( ent, adjents );
        MB_CHK_ERR( error );
    }
    return MB_SUCCESS;
}

References moab::Core::dimension_from_handle(), moab::error(), ErrorCode, get_down_adjacencies_2d(), get_down_adjacencies_edg_3d(), get_down_adjacencies_face_3d(), mb, MB_CHK_ERR, and MB_SUCCESS.

Referenced by get_adjacencies().

get_down_adjacencies_2d()

ErrorCode moab::HalfFacetRep::get_down_adjacencies_2d	(	EntityHandle	fid,
		std::vector< EntityHandle > &	adjents
	)

Given a face, finds its edges.

Given a face, it first finds incident edges on each vertex of the face, and then it performs a set intersection to gather all the edges of the given face.

Parameters

fid	EntityHandle of the query face
adjents	Vector returning its edges

Definition at line 1571 of file HalfFacetRep.cpp.

{
    // Returns explicit edges, if any, of the face
    ErrorCode error;
    adjents.reserve( 10 );
    EntityType ftype = mb->type_from_handle( fid );
    int nepf         = lConnMap2D[ftype - 2].num_verts_in_face;
 
    const EntityHandle* conn;
    error = mb->get_connectivity( fid, conn, nepf, true );
    MB_CHK_ERR( error );
 
    std::vector< EntityHandle > temp;
 
    // Loop over 2 vertices
    for( int i = 0; i < 2; i++ )
    {
        // Choose the two adjacent vertices for a triangle, and two opposite vertices for a quad
        int l;
        if( ftype == MBTRI )
            l = i;
        else
            l = 2 * i;
 
        // Get the current, next and prev vertices
        int nidx           = lConnMap2D[ftype - 2].next[l];
        int pidx           = lConnMap2D[ftype - 2].prev[l];
        EntityHandle v     = conn[l];
        EntityHandle vnext = conn[nidx];
        EntityHandle vprev = conn[pidx];
 
        // Get incident edges on v
        error = get_up_adjacencies_1d( v, temp );
        MB_CHK_ERR( error );
 
        // Loop over the incident edges and check if its end vertices match those in the face
        for( int k = 0; k < (int)temp.size(); k++ )
        {
            const EntityHandle* econn;
            int num_conn = 0;
            error        = mb->get_connectivity( temp[k], econn, num_conn, true );
            MB_CHK_ERR( error );
 
            if( ( econn[0] == v && econn[1] == vnext ) || ( econn[0] == v && econn[1] == vprev ) ||
                ( econn[0] == vnext && econn[1] == v ) || ( econn[0] == vprev && econn[1] == v ) )
            {
                bool found = false;
                for( int j = 0; j < (int)adjents.size(); j++ )
                {
                    if( adjents[j] == temp[k] )
                    {
                        found = true;
                        break;
                    }
                }
                if( !found ) adjents.push_back( temp[k] );
            }
        }
    }
 
    return MB_SUCCESS;
}

References moab::error(), ErrorCode, moab::Core::get_connectivity(), get_up_adjacencies_1d(), lConnMap2D, mb, MB_CHK_ERR, MB_SUCCESS, MBTRI, moab::HalfFacetRep::LocalMaps2D::next, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, moab::HalfFacetRep::LocalMaps2D::prev, and moab::Core::type_from_handle().

Referenced by get_down_adjacencies().

get_down_adjacencies_edg_3d()

ErrorCode moab::HalfFacetRep::get_down_adjacencies_edg_3d	(	EntityHandle	cid,
		std::vector< EntityHandle > &	adjents
	)

Given a cell, finds its edges.

Given a cell, it first finds incident edges on each vertex of the cell, and then it performs a set intersection to gather all the edges of the given cell.

Parameters

cid	EntityHandle of the query cell
adjents	Vector returning its edges

Definition at line 3068 of file HalfFacetRep.cpp.

{
    // TODO: Try intersection without using std templates
    // Returns explicit edges, if any, of the face
    ErrorCode error;
    adjents.reserve( 20 );
    int index = get_index_in_lmap( cid );
    int nvpc  = lConnMap3D[index].num_verts_in_cell;
 
    const EntityHandle* conn;
    error = mb->get_connectivity( cid, conn, nvpc, true );
    MB_CHK_ERR( error );
 
    // Gather all the incident edges on each vertex of the face
    int ns = lConnMap3D[index].search_everts[0];
    std::vector< EntityHandle > temp;
    for( int i = 0; i < ns; i++ )
    {
        temp.clear();
        int lv0 = lConnMap3D[index].search_everts[i + 1];
        error   = get_up_adjacencies_1d( conn[lv0], temp );
        MB_CHK_ERR( error );
 
        int nle   = lConnMap3D[index].v2le[i][0];
        int count = 0;
        for( int j = 0; j < (int)temp.size(); j++ )
        {
            const EntityHandle* econn;
            int nvpe = 0;
            error    = mb->get_connectivity( temp[j], econn, nvpe, true );
            MB_CHK_ERR( error );
 
            for( int k = 0; k < nle; k++ )
            {
                int lv1 = lConnMap3D[index].v2le[i][k + 1];
                if( ( ( econn[0] == conn[lv0] ) && ( econn[1] == conn[lv1] ) ) ||
                    ( ( econn[1] == conn[lv0] ) && ( econn[0] == conn[lv1] ) ) )
                {
                    adjents.push_back( temp[j] );
                    count += 1;
                }
            }
            if( count == nle ) break;
        }
    }
    return MB_SUCCESS;
}

References moab::error(), ErrorCode, moab::Core::get_connectivity(), get_index_in_lmap(), get_up_adjacencies_1d(), moab::index, lConnMap3D, mb, MB_CHK_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps3D::num_verts_in_cell, moab::HalfFacetRep::LocalMaps3D::search_everts, and moab::HalfFacetRep::LocalMaps3D::v2le.

Referenced by get_down_adjacencies().

get_down_adjacencies_face_3d()

ErrorCode moab::HalfFacetRep::get_down_adjacencies_face_3d	(	EntityHandle	cid,
		std::vector< EntityHandle > &	adjents
	)

Given a cell, finds its faces.

Given a cell, it first finds incident faces on each vertex of the cell, and then performs a set intersection to gather all the faces of the given cell.

Parameters

cid	EntityHandle of the query cell
adjents	Vector returning its faces

Definition at line 3116 of file HalfFacetRep.cpp.

{
    // Returns explicit face, if any of the cell
    ErrorCode error;
    adjents.reserve( 10 );
    int index = get_index_in_lmap( cid );
    int nvpc  = lConnMap3D[index].num_verts_in_cell;
    int nfpc  = lConnMap3D[index].num_faces_in_cell;
 
    // Get the connectivity of the input cell
    const EntityHandle* conn;
    error = mb->get_connectivity( cid, conn, nvpc, true );
    MB_CHK_ERR( error );
 
    // Collect all the half-faces of the cell
    EntityHandle half_faces[6][4];
    for( int i = 0; i < nfpc; i++ )
    {
        int nvf = lConnMap3D[index].hf2v_num[i];
        for( int j = 0; j < nvf; j++ )
        {
            int ind          = lConnMap3D[index].hf2v[i][j];
            half_faces[i][j] = conn[ind];
        }
    }
 
    // Add two vertices for which the upward adjacencies are computed
    int search_verts[2];
    search_verts[0] = lConnMap3D[index].search_fverts[0];
    search_verts[1] = lConnMap3D[index].search_fverts[1];
 
    std::vector< EntityHandle > temp;
    temp.reserve( 20 );
    for( int i = 0; i < 2; i++ )
    {
        // Get the incident faces on the local vertex
        int lv = search_verts[i];
        temp.clear();
        error = get_up_adjacencies_vert_2d( conn[lv], temp );
        MB_CHK_ERR( error );
 
        if( temp.size() == 0 ) continue;
 
        // Get the half-faces incident on the local vertex and match it with the obtained faces
        int nhfthisv = lConnMap3D[index].v2hf_num[lv];
        for( int k = 0; k < (int)temp.size(); k++ )
        {
            const EntityHandle* fid_verts;
            int fsize = 0;
            error     = mb->get_connectivity( temp[k], fid_verts, fsize, true );
            MB_CHK_ERR( error );
 
            for( int j = 0; j < nhfthisv; j++ )
            {
                // Collect all the vertices of this half-face
                int idx = lConnMap3D[index].v2hf[lv][j];
                int nvF = lConnMap3D[index].hf2v_num[idx];
 
                if( fsize != nvF ) continue;
 
                int direct, offset;
                bool they_match = CN::ConnectivityMatch( &half_faces[idx][0], &fid_verts[0], nvF, direct, offset );
 
                if( they_match )
                {
                    bool found = false;
                    for( int p = 0; p < (int)adjents.size(); p++ )
                    {
                        if( adjents[p] == temp[k] )
                        {
                            found = true;
                            break;
                        }
                    }
                    if( !found ) adjents.push_back( temp[k] );
                }
            }
        }
    }
 
    return MB_SUCCESS;
}

References moab::CN::ConnectivityMatch(), moab::error(), ErrorCode, moab::Core::get_connectivity(), get_index_in_lmap(), get_up_adjacencies_vert_2d(), moab::HalfFacetRep::LocalMaps3D::hf2v, moab::HalfFacetRep::LocalMaps3D::hf2v_num, moab::index, lConnMap3D, mb, MB_CHK_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps3D::num_verts_in_cell, moab::HalfFacetRep::LocalMaps3D::search_fverts, moab::HalfFacetRep::LocalMaps3D::v2hf, and moab::HalfFacetRep::LocalMaps3D::v2hf_num.

Referenced by get_down_adjacencies().

get_entity_ranges()

ErrorCode moab::HalfFacetRep::get_entity_ranges	(	Range &	verts,
		Range &	edges,
		Range &	faces,
		Range &	cells
	)

Definition at line 3778 of file HalfFacetRep.cpp.

{
    verts = _verts;
    edges = _edges;
    faces = _faces;
    cells = _cells;
    return MB_SUCCESS;
}

References _cells, _edges, _faces, _verts, and MB_SUCCESS.

Referenced by moab::NestedRefine::initialize().

get_face_edges()

ErrorCode moab::HalfFacetRep::get_face_edges	(	EntityHandle	fid,
		std::vector< EntityHandle > &	edges
	)

Definition at line 1673 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    edges.clear();
 
    EntityType ftype = mb->type_from_handle( fid );
    int nepf         = lConnMap2D[ftype - 2].num_verts_in_face;
 
    std::vector< EntityHandle > conn;
    error = mb->get_connectivity( &fid, 1, conn );
    MB_CHK_ERR( error );
 
    for( int i = 0; i < nepf; i++ )
    {
        EntityHandle v0 = conn[i];
        EntityHandle v1 = conn[lConnMap2D[ftype - 2].next[i]];
 
        std::vector< EntityHandle > e0, e1, ecom;
        error = get_up_adjacencies_1d( v0, e0 );
        MB_CHK_ERR( error );
        error = get_up_adjacencies_1d( v1, e1 );
        MB_CHK_ERR( error );
 
        std::sort( e0.begin(), e0.end() );
        std::sort( e1.begin(), e1.end() );
        std::set_intersection( e0.begin(), e0.end(), e1.begin(), e1.end(), std::back_inserter( ecom ) );
        assert( ecom.size() == 1 || ecom.size() == 0 );
        if( ecom.size() == 0 )
            edges.push_back( 0 );
        else
            edges.push_back( ecom[0] );
    }
 
    return MB_SUCCESS;
}

References moab::error(), ErrorCode, moab::Core::get_connectivity(), get_up_adjacencies_1d(), lConnMap2D, mb, MB_CHK_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps2D::next, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, and moab::Core::type_from_handle().

get_half_facet_in_comp()

ErrorCode moab::HalfFacetRep::get_half_facet_in_comp	(	EntityHandle	cid,
		int	leid,
		std::vector< EntityHandle > &	ents,
		std::vector< int > &	lids,
		std::vector< int > &	lfids
	)

Definition at line 3281 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    ents.clear();
    lids.clear();
    EntityType ctype = mb->type_from_handle( cid );
    int index        = get_index_in_lmap( *_cells.begin() );
    int nfpc         = lConnMap3D[index].num_faces_in_cell;
    int nvpc         = lConnMap3D[index].num_verts_in_cell;
 
    // Get all incident cells
    std::vector< EntityHandle > adjents;
    std::vector< int > adjlids;
    error = get_up_adjacencies_edg_3d( cid, leid, adjents, &adjlids );
    MB_CHK_ERR( error );
 
    // Get the end vertices of the edge <cid,leid>
    const EntityHandle* econn;
    error = mb->get_connectivity( cid, econn, nvpc, true );
    MB_CHK_ERR( error );
    int id              = lConnMap3D[index].e2v[leid][0];
    EntityHandle vstart = econn[id];
    id                  = lConnMap3D[index].e2v[leid][1];
    EntityHandle vend   = econn[id];
 
    std::vector< int > mark( adjents.size(), 0 );
    int count = 0;
 
    for( int k = 0; k < (int)adjents.size(); k++ )
    {
 
        if( mark[k] != 0 ) continue;
 
        count += 1;
        mark[k] = count;
 
        // Loop over each half-face incident on this local edge
        for( int i = 0; i < 2; i++ )
        {
            EntityHandle cur_cell = adjents[k];
            int cur_leid          = adjlids[k];
 
            int lface = i;
 
            while( true )
            {
                int cidx = ID_FROM_HANDLE( cur_cell ) - 1;
                int lfid = lConnMap3D[index].e2hf[cur_leid][lface];
 
                HFacet hf = sibhfs[nfpc * cidx + lfid];
                cur_cell  = fid_from_halfacet( hf, ctype );
                lfid      = lid_from_halffacet( hf );
 
                // Check if loop reached starting cell or a boundary
                if( ( cur_cell == adjents[k] ) || ( cur_cell == 0 ) ) break;
 
                const EntityHandle* sib_conn;
                error = mb->get_connectivity( cur_cell, sib_conn, nvpc, true );
                MB_CHK_ERR( error );
 
                // Find the local edge id wrt to sibhf
                int nv_curF = lConnMap3D[index].hf2v_num[lfid];
                int lv0 = -1, lv1 = -1, idx = -1;
                for( int j = 0; j < nv_curF; j++ )
                {
                    idx = lConnMap3D[index].hf2v[lfid][j];
                    if( vstart == sib_conn[idx] ) lv0 = idx;
                    if( vend == sib_conn[idx] ) lv1 = idx;
                }
 
                assert( ( lv0 >= 0 ) && ( lv1 >= 0 ) );
                cur_leid = lConnMap3D[index].lookup_leids[lv0][lv1];
 
                int chk_lfid = lConnMap3D[index].e2hf[cur_leid][0];
 
                if( lfid == chk_lfid )
                    lface = 1;
                else
                    lface = 0;
 
                int ind   = std::find( adjents.begin(), adjents.end(), cur_cell ) - adjents.begin();
                mark[ind] = count;
            }
 
            // Loop back
            if( cur_cell != 0 ) break;
        }
    }
 
    // Loop over again to find cells on the boundary
    for( int c = 0; c < count; c++ )
    {
        for( int i = 0; i < (int)adjents.size(); i++ )
        {
            if( mark[i] == c + 1 )
            {
                int cidx = ID_FROM_HANDLE( adjents[i] ) - 1;
                for( int j = 0; j < nfpc; j++ )
                {
                    HFacet hf         = sibhfs[nfpc * cidx + j];
                    EntityHandle cell = fid_from_halfacet( hf, ctype );
                    if( cell == 0 )
                    {
                        ents.push_back( adjents[i] );
                        lids.push_back( adjlids[i] );
                        lfids.push_back( j );
                        break;
                    }
                }
            }
        }
    }
 
    return MB_SUCCESS;
}

References _cells, moab::Range::begin(), moab::HalfFacetRep::LocalMaps3D::e2hf, moab::HalfFacetRep::LocalMaps3D::e2v, moab::error(), ErrorCode, fid_from_halfacet(), moab::Core::get_connectivity(), get_index_in_lmap(), get_up_adjacencies_edg_3d(), moab::HalfFacetRep::LocalMaps3D::hf2v, moab::HalfFacetRep::LocalMaps3D::hf2v_num, moab::ID_FROM_HANDLE(), moab::index, lConnMap3D, lid_from_halffacet(), moab::HalfFacetRep::LocalMaps3D::lookup_leids, mb, MB_CHK_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps3D::num_verts_in_cell, sibhfs, and moab::Core::type_from_handle().

get_incident_map()

ErrorCode moab::HalfFacetRep::get_incident_map	(	EntityType	type,
		EntityHandle	vid,
		std::vector< EntityHandle > &	inci_entid,
		std::vector< int > &	inci_lid
	)

Definition at line 3661 of file HalfFacetRep.cpp.

{
    inci_entid.clear();
    inci_lid.clear();
 
    if( type == MBEDGE )
    {
        HFacet hf = v2hv[ID_FROM_HANDLE( vid ) - 1];
        inci_entid.push_back( fid_from_halfacet( hf, type ) );
        inci_lid.push_back( lid_from_halffacet( hf ) );
    }
    else if( type == MBTRI || type == MBQUAD )
    {
        HFacet hf = v2he[ID_FROM_HANDLE( vid ) - 1];
        if( hf == 0 && ( v2hes.find( vid ) != v2hes.end() ) )
        {
            std::pair< std::multimap< EntityHandle, HFacet >::iterator,
                       std::multimap< EntityHandle, HFacet >::iterator >
                it_hes;
            it_hes = v2hes.equal_range( vid );
 
            for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
            {
                inci_entid.push_back( fid_from_halfacet( it->second, type ) );
                inci_lid.push_back( lid_from_halffacet( it->second ) );
            }
        }
        else if( hf != 0 )
        {
            inci_entid.push_back( fid_from_halfacet( hf, type ) );
            inci_lid.push_back( lid_from_halffacet( hf ) );
        }
        else if( hf == 0 && ( v2hes.find( vid ) == v2hes.end() ) )
        {
            inci_entid.push_back( fid_from_halfacet( hf, type ) );
            inci_lid.push_back( lid_from_halffacet( hf ) );
        }
    }
    else
    {
        HFacet hf = v2hf[ID_FROM_HANDLE( vid ) - 1];
        if( hf == 0 && ( v2hfs.find( vid ) != v2hfs.end() ) )
        {
            std::pair< std::multimap< EntityHandle, HFacet >::iterator,
                       std::multimap< EntityHandle, HFacet >::iterator >
                it_hes;
            it_hes = v2hfs.equal_range( vid );
 
            for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
            {
                inci_entid.push_back( fid_from_halfacet( it->second, type ) );
                inci_lid.push_back( lid_from_halffacet( it->second ) );
            }
        }
        else if( hf != 0 )
        {
            inci_entid.push_back( fid_from_halfacet( hf, type ) );
            inci_lid.push_back( lid_from_halffacet( hf ) );
        }
        else if( hf == 0 && ( v2hfs.find( vid ) == v2hfs.end() ) )
        {
            inci_entid.push_back( fid_from_halfacet( hf, type ) );
            inci_lid.push_back( lid_from_halffacet( hf ) );
        }
    }
 
    return MB_SUCCESS;
}

References fid_from_halfacet(), moab::ID_FROM_HANDLE(), lid_from_halffacet(), MB_SUCCESS, MBEDGE, MBQUAD, MBTRI, v2he, v2hes, v2hf, v2hfs, and v2hv.

Referenced by moab::NestedRefine::is_vertex_on_boundary(), moab::NestedRefine::update_global_ahf_1D(), moab::NestedRefine::update_global_ahf_1D_sub(), moab::NestedRefine::update_global_ahf_2D(), moab::NestedRefine::update_global_ahf_2D_sub(), moab::NestedRefine::update_global_ahf_3D(), and moab::NestedRefine::update_local_ahf().

get_index_for_meshtype()

int moab::HalfFacetRep::get_index_for_meshtype ( MESHTYPE  mesh_type )

protected

Definition at line 101 of file HalfFacetRep.cpp.

{
    int index = 0;
    switch( mesh_type )
    {
        case CURVE:
            index = 0;
            break;
        case SURFACE:
            index = 1;
            break;
        case SURFACE_MIXED:
            index = 2;
            break;
        case VOLUME:
            index = 3;
            break;
        case VOLUME_MIXED_1:
            index = 4;
            break;
        case VOLUME_MIXED_2:
            index = 5;
            break;
        case VOLUME_MIXED:
            index = 6;
            break;
    }
    return index;
}

References moab::CURVE, moab::index, moab::SURFACE, moab::SURFACE_MIXED, moab::VOLUME, moab::VOLUME_MIXED, moab::VOLUME_MIXED_1, and moab::VOLUME_MIXED_2.

Referenced by get_adjacencies().

get_index_in_lmap()

int moab::HalfFacetRep::get_index_in_lmap

(

EntityHandle

cid

)

Definition at line 1713 of file HalfFacetRep.cpp.

{
    EntityType type = mb->type_from_handle( cid );
    int index       = cell_index.find( type )->second;
    return index;
}

References cell_index, moab::index, mb, and moab::Core::type_from_handle().

Referenced by add_cells_of_single_component(), moab::NestedRefine::construct_hm_1D(), moab::NestedRefine::construct_hm_2D(), moab::NestedRefine::create_hm_storage_single_level(), determine_border_vertices(), determine_incident_halffaces(), determine_sibling_halffaces(), find_matching_halfface(), find_matching_implicit_edge_in_cell(), find_total_edges_faces_3d(), moab::NestedRefine::get_connectivity(), get_down_adjacencies_edg_3d(), get_down_adjacencies_face_3d(), get_half_facet_in_comp(), moab::NestedRefine::get_lid_inci_child(), get_neighbor_adjacencies_3d(), get_sibling_map(), get_up_adjacencies_edg_3d(), get_up_adjacencies_edg_3d_comp(), get_up_adjacencies_face_3d(), get_up_adjacencies_vert_3d(), init_volume(), moab::NestedRefine::is_cell_on_boundary(), moab::NestedRefine::is_edge_on_boundary(), moab::NestedRefine::is_vertex_on_boundary(), print_tags(), moab::NestedRefine::reorder_indices(), resize_hf_maps(), set_sibling_map(), moab::NestedRefine::subdivide_cells(), moab::NestedRefine::subdivide_tets(), moab::NestedRefine::update_global_ahf_3D(), moab::NestedRefine::update_local_ahf(), and moab::NestedRefine::update_tracking_verts().

get_memory_use()

void moab::HalfFacetRep::get_memory_use	(	unsigned long long &	entity_total,
		unsigned long long &	memory_total
	)

Definition at line 3806 of file HalfFacetRep.cpp.

{
    entity_total = memory_total = 0;
    // 1D
    if( !v2hv.empty() ) entity_total += v2hv.capacity() * sizeof( HFacet ) + sizeof( v2hv );
    if( !sibhvs.empty() ) entity_total += sibhvs.capacity() * sizeof( HFacet ) + sizeof( sibhvs );
 
    // 2D
    if( !v2he.empty() ) entity_total += v2he.capacity() * sizeof( HFacet ) + sizeof( v2he );
    if( !sibhes.empty() ) entity_total += sibhes.capacity() * sizeof( HFacet ) + sizeof( sibhes );
 
    // 3D
    if( !v2hf.empty() ) entity_total += v2hf.capacity() * sizeof( HFacet ) + sizeof( v2hf );
    if( !sibhfs.empty() ) entity_total += sibhfs.capacity() * sizeof( HFacet ) + sizeof( sibhfs );
 
    memory_total = entity_total;
}

References sibhes, sibhfs, sibhvs, v2he, v2hf, and v2hv.

get_mesh_type()

MESHTYPE moab::HalfFacetRep::get_mesh_type	(	int	nverts,
		int	nedges,
		int	nfaces,
		int	ncells
	)

Definition at line 56 of file HalfFacetRep.cpp.

{
    MESHTYPE mesh_type = CURVE;
 
    if( nverts && nedges && ( !nfaces ) && ( !ncells ) )
        mesh_type = CURVE;
    else if( nverts && !nedges && nfaces && !ncells )
        mesh_type = SURFACE;
    else if( nverts && nedges && nfaces && !ncells )
        mesh_type = SURFACE_MIXED;
    else if( nverts && !nedges && !nfaces && ncells )
        mesh_type = VOLUME;
    else if( nverts && nedges && !nfaces && ncells )
        mesh_type = VOLUME_MIXED_1;
    else if( nverts && !nedges && nfaces && ncells )
        mesh_type = VOLUME_MIXED_2;
    else if( nverts && nedges && nfaces && ncells )
        mesh_type = VOLUME_MIXED;
 
    return mesh_type;
}

References moab::CURVE, moab::SURFACE, moab::SURFACE_MIXED, moab::VOLUME, moab::VOLUME_MIXED, moab::VOLUME_MIXED_1, and moab::VOLUME_MIXED_2.

Referenced by moab::NestedRefine::create_hm_storage_single_level(), and initialize().

get_neighbor_adjacencies()

ErrorCode moab::HalfFacetRep::get_neighbor_adjacencies	(	EntityHandle	ent,
		std::vector< EntityHandle > &	adjents
	)

Get the same-dimensional entities connected with an entity.

Given an entity of dimension d, gather all the entities connected via d-1 dimensional entities. Same as bridge_adjacencies in MOAB.

Parameters

ent	EntityHandle to which neighbor entities have to be found.
adjents	Vector in which the neighbor entities are returned.

Definition at line 616 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    int in_dim = mb->dimension_from_handle( ent );
    assert( in_dim >= 1 && in_dim <= 3 );
 
    if( in_dim == 1 )
    {
        error = get_neighbor_adjacencies_1d( ent, adjents );
        MB_CHK_ERR( error );
    }
 
    else if( in_dim == 2 )
    {
        error = get_neighbor_adjacencies_2d( ent, adjents );
        MB_CHK_ERR( error );
    }
    else if( in_dim == 3 )
    {
        error = get_neighbor_adjacencies_3d( ent, adjents );
        MB_CHK_ERR( error );
    }
    return MB_SUCCESS;
}

References moab::Core::dimension_from_handle(), moab::error(), ErrorCode, get_neighbor_adjacencies_1d(), get_neighbor_adjacencies_2d(), get_neighbor_adjacencies_3d(), mb, MB_CHK_ERR, and MB_SUCCESS.

Referenced by get_adjacencies().

get_neighbor_adjacencies_1d()

ErrorCode moab::HalfFacetRep::get_neighbor_adjacencies_1d	(	EntityHandle	eid,
		std::vector< EntityHandle > &	adjents
	)

Given an edge, finds vertex-connected neighbor edges.

Given an edge, it gathers all the incident edges of each vertex of the edge.

Parameters

eid	EntityHandle of the query edge
adjents	Vector returning neighbor edges

Definition at line 837 of file HalfFacetRep.cpp.

{
    adjents.clear();
    adjents.reserve( 20 );
 
    EntityHandle sibhv_eid;
    int sibhv_lid;
    int eidx = ID_FROM_HANDLE( eid ) - 1;
 
    for( int lid = 0; lid < 2; ++lid )
    {
        HFacet shf = sibhvs[2 * eidx + lid];
        sibhv_eid  = fid_from_halfacet( shf, MBEDGE );
        sibhv_lid  = lid_from_halffacet( shf );
 
        if( sibhv_eid != 0 )
        {
            adjents.push_back( sibhv_eid );
 
            eidx                = ID_FROM_HANDLE( sibhv_eid ) - 1;
            HFacet nhf          = sibhvs[2 * eidx + sibhv_lid];
            EntityHandle hv_eid = fid_from_halfacet( nhf, MBEDGE );
            int hv_lid          = lid_from_halffacet( nhf );
 
            while( hv_eid != 0 )
            {
                if( hv_eid != eid ) adjents.push_back( hv_eid );
 
                eidx              = ID_FROM_HANDLE( hv_eid ) - 1;
                HFacet hf         = sibhvs[2 * eidx + hv_lid];
                EntityHandle edge = fid_from_halfacet( hf, MBEDGE );
                if( edge == sibhv_eid ) break;
 
                hv_eid = edge;
                hv_lid = lid_from_halffacet( hf );
            }
        }
    }
 
    return MB_SUCCESS;
}

References fid_from_halfacet(), moab::ID_FROM_HANDLE(), lid_from_halffacet(), MB_SUCCESS, MBEDGE, and sibhvs.

Referenced by get_neighbor_adjacencies().

get_neighbor_adjacencies_2d()

ErrorCode moab::HalfFacetRep::get_neighbor_adjacencies_2d	(	EntityHandle	fid,
		std::vector< EntityHandle > &	adjents
	)

Given an edge, finds edge-connected neighbor face.

Given an face, it gathers all the neighbor faces of each local edge of the face.

Parameters

fid	EntityHandle of the query face
adjents	Vector returning neighbor faces

Definition at line 1551 of file HalfFacetRep.cpp.

{
    ErrorCode error;
 
    if( fid != 0 )
    {
        EntityType ftype = mb->type_from_handle( fid );
        int nepf         = lConnMap2D[ftype - 2].num_verts_in_face;
 
        for( int lid = 0; lid < nepf; ++lid )
        {
            error = get_up_adjacencies_2d( fid, lid, false, adjents );
            MB_CHK_ERR( error );
        }
    }
 
    return MB_SUCCESS;
}

References moab::error(), ErrorCode, get_up_adjacencies_2d(), lConnMap2D, mb, MB_CHK_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, and moab::Core::type_from_handle().

Referenced by get_neighbor_adjacencies().

get_neighbor_adjacencies_3d()

ErrorCode moab::HalfFacetRep::get_neighbor_adjacencies_3d	(	EntityHandle	cid,
		std::vector< EntityHandle > &	adjents
	)

Given a cell, finds face-connected neighbor cells.

Given a cell, it gathers all the neighbor cells of each local face of the cell.

Parameters

cid	EntityHandle of the query cell
adjents	Vector returning neighbor cells

Definition at line 3046 of file HalfFacetRep.cpp.

{
    adjents.reserve( 20 );
    EntityType ctype = mb->type_from_handle( cid );
    int index        = get_index_in_lmap( cid );
    int nfpc         = lConnMap3D[index].num_faces_in_cell;
    int cidx         = ID_FROM_HANDLE( cid ) - 1;
 
    if( cid != 0 )
    {
        for( int lfid = 0; lfid < nfpc; ++lfid )
        {
            HFacet hf           = sibhfs[nfpc * cidx + lfid];
            EntityHandle sibcid = fid_from_halfacet( hf, ctype );
            if( sibcid != 0 ) adjents.push_back( sibcid );
        }
    }
 
    return MB_SUCCESS;
}

References fid_from_halfacet(), get_index_in_lmap(), moab::ID_FROM_HANDLE(), moab::index, lConnMap3D, mb, MB_SUCCESS, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, sibhfs, and moab::Core::type_from_handle().

Referenced by get_neighbor_adjacencies().

get_rset()

EntityHandle* moab::HalfFacetRep::get_rset ( )

inline

Definition at line 544 of file HalfFacetRep.hpp.

    {
        return &_rset;
    }

References _rset.

get_sibling_map() [1/2]

ErrorCode moab::HalfFacetRep::get_sibling_map	(	EntityType	type,
		EntityHandle	ent,
		EntityHandle *	sib_entids,
		int *	sib_lids,
		int	num_halffacets
	)

Definition at line 3503 of file HalfFacetRep.cpp.

{
 
    if( type == MBEDGE )
    {
        if( num_halffacets != 2 ) MB_SET_ERR( MB_FAILURE, "Incorrect number of halfvertices." );
 
        int eidx = ID_FROM_HANDLE( ent ) - 1;
        for( int i = 0; i < 2; i++ )
        {
            HFacet hf     = sibhvs[2 * eidx + i];
            sib_entids[i] = fid_from_halfacet( hf, MBEDGE );
            sib_lids[i]   = lid_from_halffacet( hf );
        }
    }
    else if( type == MBTRI || type == MBQUAD )
    {
        int nepf = lConnMap2D[type - 2].num_verts_in_face;
 
        if( num_halffacets != nepf ) MB_SET_ERR( MB_FAILURE, "Incorrect number of halfedges." );
 
        int fidx = ID_FROM_HANDLE( ent ) - 1;
        for( int i = 0; i < nepf; i++ )
        {
            HFacet hf     = sibhes[nepf * fidx + i];
            sib_entids[i] = fid_from_halfacet( hf, type );
            sib_lids[i]   = lid_from_halffacet( hf );
        }
    }
    else
    {
        int idx  = get_index_in_lmap( *_cells.begin() );
        int nfpc = lConnMap3D[idx].num_faces_in_cell;
 
        if( num_halffacets != nfpc ) MB_SET_ERR( MB_FAILURE, "Incorrect number of halffaces." );
 
        int cidx = ID_FROM_HANDLE( ent ) - 1;
        for( int i = 0; i < nfpc; i++ )
        {
            HFacet hf     = sibhfs[nfpc * cidx + i];
            sib_entids[i] = fid_from_halfacet( hf, type );
            sib_lids[i]   = lid_from_halffacet( hf );
        }
    }
    return MB_SUCCESS;
}

References _cells, moab::Range::begin(), fid_from_halfacet(), get_index_in_lmap(), moab::ID_FROM_HANDLE(), lConnMap2D, lConnMap3D, lid_from_halffacet(), MB_SET_ERR, MB_SUCCESS, MBEDGE, MBQUAD, MBTRI, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, sibhes, sibhfs, and sibhvs.

Referenced by moab::NestedRefine::is_cell_on_boundary(), moab::NestedRefine::is_edge_on_boundary(), moab::NestedRefine::is_face_on_boundary(), moab::NestedRefine::is_vertex_on_boundary(), moab::NestedRefine::update_global_ahf_1D(), moab::NestedRefine::update_global_ahf_1D_sub(), moab::NestedRefine::update_global_ahf_2D(), moab::NestedRefine::update_global_ahf_2D_sub(), moab::NestedRefine::update_global_ahf_3D(), and moab::NestedRefine::update_local_ahf().

get_sibling_map() [2/2]

ErrorCode moab::HalfFacetRep::get_sibling_map	(	EntityType	type,
		EntityHandle	ent,
		int	lid,
		EntityHandle &	sib_entid,
		int &	sib_lid
	)

Definition at line 3554 of file HalfFacetRep.cpp.

{
 
    if( type == MBEDGE )
    {
        int eidx  = ID_FROM_HANDLE( ent ) - 1;
        HFacet hf = sibhvs[2 * eidx + lid];
        sib_entid = fid_from_halfacet( hf, MBEDGE );
        sib_lid   = lid_from_halffacet( hf );
    }
    else if( type == MBTRI || type == MBQUAD )
    {
        int nepf  = lConnMap2D[type - 2].num_verts_in_face;
        int fidx  = ID_FROM_HANDLE( ent ) - 1;
        HFacet hf = sibhes[nepf * fidx + lid];
        sib_entid = fid_from_halfacet( hf, type );
        sib_lid   = lid_from_halffacet( hf );
    }
    else
    {
        int idx   = get_index_in_lmap( *_cells.begin() );
        int nfpc  = lConnMap3D[idx].num_faces_in_cell;
        int cidx  = ID_FROM_HANDLE( ent ) - 1;
        HFacet hf = sibhfs[nfpc * cidx + lid];
        sib_entid = fid_from_halfacet( hf, type );
        sib_lid   = lid_from_halffacet( hf );
    }
    return MB_SUCCESS;
}

References _cells, moab::Range::begin(), fid_from_halfacet(), get_index_in_lmap(), moab::ID_FROM_HANDLE(), lConnMap2D, lConnMap3D, lid_from_halffacet(), MB_SUCCESS, MBEDGE, MBQUAD, MBTRI, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, sibhes, sibhfs, and sibhvs.

get_up_adjacencies()

ErrorCode moab::HalfFacetRep::get_up_adjacencies	(	EntityHandle	ent,
		int	out_dim,
		std::vector< EntityHandle > &	adjents,
		std::vector< int > *	lids = NULL
	)

Get the upward incidences associated with an entity.

Given an entity of dimension d, gather all the incident D(>d) dimensional entities. :

Parameters

ent	EntityHandle to which incident entities have to be found.
out_dim	Dimension of the desired incidence information.
adjents	Vector in which the incident entities are returned.
local_id	Set to false by default. If true, returns the local id's of the half-facets
lids	Vector in which the local id's are returned.

Definition at line 570 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    int in_dim = mb->dimension_from_handle( ent );
    assert( ( in_dim >= 0 && in_dim <= 2 ) && ( out_dim > in_dim ) );
 
    if( in_dim == 0 )
    {
        if( out_dim == 1 )
        {
            error = get_up_adjacencies_1d( ent, adjents, lids );
            MB_CHK_ERR( error );
        }
        else if( out_dim == 2 )
        {
            error = get_up_adjacencies_vert_2d( ent, adjents );
            MB_CHK_ERR( error );
        }
        else if( out_dim == 3 )
        {
            error = get_up_adjacencies_vert_3d( ent, adjents );
            MB_CHK_ERR( error );
        }
    }
 
    else if( ( in_dim == 1 ) && ( out_dim == 2 ) )
    {
        error = get_up_adjacencies_2d( ent, adjents, lids );
        MB_CHK_ERR( error );
    }
    else if( ( in_dim == 1 ) && ( out_dim == 3 ) )
    {
        error = get_up_adjacencies_edg_3d( ent, adjents, lids );
        MB_CHK_ERR( error );
    }
    else if( ( in_dim == 2 ) && ( out_dim == 3 ) )
    {
        error = get_up_adjacencies_face_3d( ent, adjents, lids );
        MB_CHK_ERR( error );
    }
    return MB_SUCCESS;
}

References moab::Core::dimension_from_handle(), moab::error(), ErrorCode, get_up_adjacencies_1d(), get_up_adjacencies_2d(), get_up_adjacencies_edg_3d(), get_up_adjacencies_face_3d(), get_up_adjacencies_vert_2d(), get_up_adjacencies_vert_3d(), mb, MB_CHK_ERR, and MB_SUCCESS.

Referenced by get_adjacencies(), and moab::HiReconstruction::vertex_get_incident_elements().

get_up_adjacencies_1d()

ErrorCode moab::HalfFacetRep::get_up_adjacencies_1d	(	EntityHandle	vid,
		std::vector< EntityHandle > &	adjents,
		std::vector< int > *	lvids = NULL
	)

Given a vertex, finds the edges incident on it.

Given a vertex handle, it starts by first finding an incident half-vert by using the incident half-vert map, and then obtaining all the sibling half-verts of the corresponding half-vertex.

Parameters

vid	EntityHandle of the query vertex
adjents	Vector returning the incident edges
local_id	False by default. If true, returns the local vertex id's corresponding to vid
lvids	Vector returning the local vertex id's

Definition at line 797 of file HalfFacetRep.cpp.

{
    adjents.clear();
    adjents.reserve( 20 );
 
    if( lvids != NULL ) lvids->reserve( 20 );
 
    int vidx  = ID_FROM_HANDLE( vid ) - 1;
    HFacet hf = v2hv[vidx];
 
    EntityHandle start_eid = fid_from_halfacet( hf, MBEDGE );
    int start_lid          = lid_from_halffacet( hf );
 
    EntityHandle eid = start_eid;
    int lid          = start_lid;
 
    if( eid != 0 )
    {
        adjents.push_back( eid );
        if( lvids != NULL ) lvids->push_back( lid );
 
        while( eid != 0 )
        {
            int eidx   = ID_FROM_HANDLE( eid ) - 1;
            HFacet shf = sibhvs[2 * eidx + lid];
            eid        = fid_from_halfacet( shf, MBEDGE );
            lid        = lid_from_halffacet( shf );
 
            if( ( !eid ) || ( eid == start_eid ) ) break;
 
            adjents.push_back( eid );
            if( lvids != NULL ) lvids->push_back( lid );
        }
    }
 
    return MB_SUCCESS;
}

References fid_from_halfacet(), moab::ID_FROM_HANDLE(), lid_from_halffacet(), MB_SUCCESS, MBEDGE, sibhvs, and v2hv.

Referenced by get_down_adjacencies_2d(), get_down_adjacencies_edg_3d(), get_face_edges(), get_up_adjacencies(), moab::NestedRefine::vertex_to_entities_down(), and moab::NestedRefine::vertex_to_entities_up().

get_up_adjacencies_2d() [1/3]

ErrorCode moab::HalfFacetRep::get_up_adjacencies_2d	(	EntityHandle	eid,
		std::vector< EntityHandle > &	adjents,
		std::vector< int > *	leids = NULL
	)

Given an edge, finds the faces incident on it.

Given an edge, it first finds a matching half-edge corresponding to eid, and then collects all the incident half-edges/faces via the sibhes map.

Parameters

eid	EntityHandle of the query edge
adjents	Vector returning the incident faces
local_id	By default false. If true, returns the local edge id's corresponding to the input edge
leids	Vector returning local edge ids

Definition at line 1239 of file HalfFacetRep.cpp.

{
 
    // Given an explicit edge eid, find the incident faces.
    ErrorCode error;
    EntityHandle he_fid = 0;
    int he_lid          = 0;
 
    // Step 1: Given an explicit edge, find a corresponding half-edge from the surface mesh.
    bool found = find_matching_halfedge( eid, &he_fid, &he_lid );
 
    // Step 2: If there is a corresponding half-edge, collect all sibling half-edges and store the
    // incident faces.
    if( found )
    {
        error = get_up_adjacencies_2d( he_fid, he_lid, true, adjents, leids );
        MB_CHK_ERR( error );
    }
 
    return MB_SUCCESS;
}

References moab::error(), ErrorCode, find_matching_halfedge(), MB_CHK_ERR, and MB_SUCCESS.

Referenced by collect_and_compare(), moab::NestedRefine::construct_hm_1D(), moab::NestedRefine::construct_hm_2D(), find_total_edges_2d(), gather_halfedges(), get_neighbor_adjacencies_2d(), get_up_adjacencies(), get_up_adjacencies_vert_2d(), moab::NestedRefine::is_edge_on_boundary(), and mark_halfedges().

get_up_adjacencies_2d() [2/3]

ErrorCode moab::HalfFacetRep::get_up_adjacencies_2d	(	EntityHandle	fid,
		int	leid,
		bool	add_inent,
		std::vector< EntityHandle > &	adj_ents,
		std::vector< int > *	adj_leids = NULL,
		std::vector< int > *	adj_orients = NULL
	)

Given a half-edge <fid, leid>, finds the faces incident on it.

Parameters

fid	EntityHandle of the containing face
leid	local id of the edge w.r.t to the face
add_inent	If true, adds the input fid into the returning vector of adjents.
adjents	Vector returning the incident faces
local_id	By default false. If true, returns the local edge id's as well.
leids	Vector returning local edge ids

Definition at line 1264 of file HalfFacetRep.cpp.

{
    // Given an implicit half-edge <fid, leid>, find the incident half-edges.
    ErrorCode error;
 
    EntityType ftype = mb->type_from_handle( fid );
    int nepf         = lConnMap2D[ftype - 2].num_verts_in_face;
 
    if( !fid ) return MB_FAILURE;
    adj_ents.reserve( 20 );
 
    bool local_id = false;
    bool orient   = false;
    if( adj_leids != NULL )
    {
        local_id = true;
        adj_leids->reserve( 20 );
    }
    if( adj_orients != NULL )
    {
        orient = true;
        adj_orients->reserve( 20 );
    }
 
    if( add_inent )
    {
        adj_ents.push_back( fid );
        if( local_id ) adj_leids->push_back( leid );
    }
 
    EntityHandle fedge[2] = { 0, 0 };
 
    if( orient )
    {
        // get connectivity and match their directions
        const EntityHandle* fid_conn;
        error = mb->get_connectivity( fid, fid_conn, nepf, true );
        MB_CHK_ERR( error );
 
        int nidx = lConnMap2D[ftype - 2].next[leid];
        fedge[0] = fid_conn[leid];
        fedge[1] = fid_conn[nidx];
    }
 
    int fidx            = ID_FROM_HANDLE( fid ) - 1;
    HFacet hf           = sibhes[nepf * fidx + leid];
    EntityHandle curfid = fid_from_halfacet( hf, ftype );
    int curlid          = lid_from_halffacet( hf );
 
    while( ( curfid != fid ) && ( curfid != 0 ) )
    {  // Should not go into the loop when no sibling exists
        adj_ents.push_back( curfid );
 
        if( local_id ) adj_leids->push_back( curlid );
 
        if( orient )
        {
            // get connectivity and match their directions
            const EntityHandle* conn;
            error = mb->get_connectivity( curfid, conn, nepf, true );
            MB_CHK_ERR( error );
 
            int nidx = lConnMap2D[ftype - 2].next[curlid];
 
            if( ( fedge[0] == conn[curlid] ) && ( fedge[1] == conn[nidx] ) )
                adj_orients->push_back( 1 );
            else if( ( fedge[1] == conn[curlid] ) && ( fedge[0] == conn[nidx] ) )
                adj_orients->push_back( 0 );
        }
 
        int cidx = ID_FROM_HANDLE( curfid ) - 1;
        hf       = sibhes[nepf * cidx + curlid];
        curfid   = fid_from_halfacet( hf, ftype );
        curlid   = lid_from_halffacet( hf );
    }
 
    return MB_SUCCESS;
}

References moab::error(), ErrorCode, fid_from_halfacet(), moab::Core::get_connectivity(), moab::ID_FROM_HANDLE(), lConnMap2D, lid_from_halffacet(), mb, MB_CHK_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps2D::next, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, sibhes, and moab::Core::type_from_handle().

get_up_adjacencies_2d() [3/3]

ErrorCode moab::HalfFacetRep::get_up_adjacencies_2d ( EntityHandle  he_fid, int  he_lid, int *  qsize, int *  count  )

protected

Contains the local information for 2D entities.

Given a face, find the face type specific information

Parameters

face	EntityHandle. Used to gather info about the type of face for which local info is required
nepf	Returns the number of vertices/edges for given face type. Contains the local information for 2D entities Given number of edges, returns local indices of next and previous local edges.
nepf	The number of vertices/edges for given face type.
next,prev	Local ids of next and previous edges w.r.t to the face

Note: For 2D entities, the number of vertices and edges are same and each local edge is outgoing corresponding to the local vertex, i.e,

 v2        v3 __e2__v2
 /\          |      |

e2 / \ e1 e3| |e1 /____\ |______| v0 e0 v1 v0 e0 v1 Given a half-edge as <he_fid,he_lid> , finds the half-edges incident on it and adds them Given an half-edge, obtain all the incident half-edges via the sibhes map and add them to a given queue of half-edges, if they do not already exist in the queue. This function is used to increment the search space for finding a matching half-edge.

Parameters

he_fid	EntityHandle of query half-edge
he_lid	Local id of query half-edge

Definition at line 1349 of file HalfFacetRep.cpp.

{
    EntityType ftype = mb->type_from_handle( fid );
    int nepf         = lConnMap2D[ftype - 2].num_verts_in_face;
 
    int fidx            = ID_FROM_HANDLE( fid ) - 1;
    HFacet hf           = sibhes[nepf * fidx + lid];
    EntityHandle curfid = fid_from_halfacet( hf, ftype );
    int curlid          = lid_from_halffacet( hf );
 
    if( curfid == 0 )
    {
        int index      = 0;
        bool found_ent = find_match_in_array( fid, queue_fid, qsize[0] - 1, true, &index );
 
        if( ( !found_ent ) || ( ( found_ent ) && ( queue_lid[index] != lid ) ) )
        {
            queue_fid[qsize[0]] = fid;
            queue_lid[qsize[0]] = lid;
            qsize[0] += 1;
        }
    }
 
    while( ( curfid != fid ) && ( curfid != 0 ) )
    {
        bool val = find_match_in_array( curfid, trackfaces, count[0] );
 
        if( !val )
        {
            queue_fid[qsize[0]] = curfid;
            queue_lid[qsize[0]] = curlid;
            qsize[0] += 1;
        }
 
        int cidx = ID_FROM_HANDLE( curfid ) - 1;
        hf       = sibhes[nepf * cidx + curlid];
        curfid   = fid_from_halfacet( hf, ftype );
        curlid   = lid_from_halffacet( hf );
    }
 
    return MB_SUCCESS;
}

References fid_from_halfacet(), find_match_in_array(), moab::ID_FROM_HANDLE(), moab::index, lConnMap2D, lid_from_halffacet(), mb, MB_SUCCESS, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, queue_fid, queue_lid, sibhes, trackfaces, and moab::Core::type_from_handle().

get_up_adjacencies_edg_3d() [1/2]

ErrorCode moab::HalfFacetRep::get_up_adjacencies_edg_3d	(	EntityHandle	cid,
		int	leid,
		std::vector< EntityHandle > &	adjents,
		std::vector< int > *	leids = NULL,
		std::vector< int > *	adj_orients = NULL
	)

Given a local edge <cid, leid>, finds the cells incident on it.

Given a local edge, it gathers all the incident cells via the sibhfs map.

Parameters

cid	EntityHandle of the cell containing the local edge
leid	local edge id w.r.t the cell
adjents	Vector returning the incident cells
local_id	By default false. If true, returns the local edge id's corresponding to the input edge
leids	Vector returning local edge ids

Definition at line 2404 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityType ctype = mb->type_from_handle( cid );
    int index        = get_index_in_lmap( cid );
    int nvpc         = lConnMap3D[index].num_verts_in_cell;
    int nfpc         = lConnMap3D[index].num_faces_in_cell;
    adjents.clear();
    adjents.reserve( 20 );
 
    if( leids != NULL )
    {
        leids->clear();
        leids->reserve( 20 );
    }
    if( adj_orients != NULL )
    {
        adj_orients->clear();
        adj_orients->reserve( 20 );
    }
 
    const EntityHandle* econn;
    error = mb->get_connectivity( cid, econn, nvpc, true );
    MB_CHK_ERR( error );
 
    // Get the end vertices of the edge <cid,leid>
    int id               = lConnMap3D[index].e2v[leid][0];
    EntityHandle v_start = econn[id];
    id                   = lConnMap3D[index].e2v[leid][1];
    EntityHandle v_end   = econn[id];
 
    int v1idx = ID_FROM_HANDLE( v_start ) - 1;
    int v2idx = ID_FROM_HANDLE( v_end ) - 1;
 
    // Find an half-facets incident to each end vertex of the edge
    std::vector< EntityHandle > start_cells;
    HFacet hf1 = v2hf[v1idx];
    HFacet hf2 = v2hf[v2idx];
 
    if( hf1 == 0 && !v2hfs.empty() )
    {
        std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
            it_hes;
        it_hes = v2hfs.equal_range( v_start );
 
        for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
        {
            start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
        }
    }
    else if( hf1 != 0 )
    {
        start_cells.push_back( fid_from_halfacet( hf1, ctype ) );
    }
 
    if( hf2 == 0 && !v2hfs.empty() )
    {
        std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
            it_hes;
        it_hes = v2hfs.equal_range( v_end );
 
        for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
        {
            start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
        }
    }
    else if( hf2 != 0 )
    {
        start_cells.push_back( fid_from_halfacet( hf2, ctype ) );
    }
 
    if( start_cells.empty() ) return MB_SUCCESS;
 
    std::sort( start_cells.begin(), start_cells.end() );
    std::vector< EntityHandle >::iterator last = std::unique( start_cells.begin(), start_cells.end() );
    start_cells.erase( last, start_cells.end() );
 
    for( int i = 0; i < (int)start_cells.size(); i++ )
        cellq[i] = start_cells[i];
 
    int qsize     = start_cells.size();
    int num_qvals = 0;
 
    while( num_qvals < qsize )
    {
        EntityHandle cell_id = cellq[num_qvals];
        num_qvals += 1;
 
        const EntityHandle* conn;
        error = mb->get_connectivity( cell_id, conn, nvpc, true );
        MB_CHK_ERR( error );
 
        int lv0 = -1, lv1 = -1, lv = -1;
 
        // locate v_origin in poped out tet, check if v_end is in
        for( int i = 0; i < nvpc; i++ )
        {
            if( v_start == conn[i] )
            {
                lv0 = i;
                lv  = lv0;
            }
            else if( v_end == conn[i] )
            {
                lv1 = i;
                lv  = lv1;
            }
        }
 
        if( ( lv0 >= 0 ) && ( lv1 >= 0 ) )
        {
            adjents.push_back( cell_id );
            if( leids != NULL ) leids->push_back( lConnMap3D[index].lookup_leids[lv0][lv1] );
 
            if( adj_orients != NULL )
            {
                int cur_leid = lConnMap3D[index].lookup_leids[lv0][lv1];
                int id1      = lConnMap3D[index].e2v[cur_leid][0];
                int id2      = lConnMap3D[index].e2v[cur_leid][1];
                if( ( v_start == conn[id1] ) && ( v_end == conn[id2] ) )
                    adj_orients->push_back( 1 );
                else if( ( v_start == conn[id2] ) && ( v_end == conn[id1] ) )
                    adj_orients->push_back( 0 );
            }
        }
        if( lv < 0 ) MB_SET_ERR( MB_FAILURE, "did not find local vertex " );
        // push back new found unchecked incident tets of v_start
        int cidx      = ID_FROM_HANDLE( cell_id ) - 1;
        int nhf_thisv = lConnMap3D[index].v2hf_num[lv];
 
        for( int i = 0; i < nhf_thisv; i++ )
        {
            int ind          = lConnMap3D[index].v2hf[lv][i];
            HFacet hf        = sibhfs[nfpc * cidx + ind];
            EntityHandle ngb = fid_from_halfacet( hf, ctype );
 
            if( ngb )
            {
                bool found_ent = find_match_in_array( ngb, &cellq[0], qsize - 1 );
 
                if( !found_ent )
                {
                    cellq[qsize] = ngb;
                    qsize += 1;
                }
            }
        }
    }
 
    for( int i = 0; i < qsize; i++ )
        cellq[i] = 0;
 
    return MB_SUCCESS;
}

References cellq, moab::HalfFacetRep::LocalMaps3D::e2v, moab::error(), ErrorCode, fid_from_halfacet(), find_match_in_array(), moab::Core::get_connectivity(), get_index_in_lmap(), moab::ID_FROM_HANDLE(), moab::index, lConnMap3D, moab::HalfFacetRep::LocalMaps3D::lookup_leids, mb, MB_CHK_ERR, MB_SET_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps3D::num_verts_in_cell, sibhfs, moab::Core::type_from_handle(), moab::HalfFacetRep::LocalMaps3D::v2hf, v2hf, moab::HalfFacetRep::LocalMaps3D::v2hf_num, and v2hfs.

get_up_adjacencies_edg_3d() [2/2]

ErrorCode moab::HalfFacetRep::get_up_adjacencies_edg_3d	(	EntityHandle	eid,
		std::vector< EntityHandle > &	adjents,
		std::vector< int > *	leids = NULL
	)

Given an edge, finds the cells incident on it.

Given an edge, it first finds a matching local edge in a cell corresponding to eid, and then collects all the incident cells via the sibhfs map.

Parameters

eid	EntityHandle of the query edge
adjents	Vector returning the incident cells
local_id	By default false. If true, returns the local edge id's corresponding to the input edge
leids	Vector returning local edge ids

Definition at line 2269 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityType ctype        = mb->type_from_handle( *_cells.begin() );
    EntityHandle start_cell = *_cells.begin();
    int index               = get_index_in_lmap( start_cell );
    int nvpc                = lConnMap3D[index].num_verts_in_cell;
    int nfpc                = lConnMap3D[index].num_faces_in_cell;
 
    adjents.reserve( 20 );
    if( leids != NULL ) leids->reserve( 20 );
 
    // Find the edge vertices
    const EntityHandle* econn;
    int num_conn = 0;
    error        = mb->get_connectivity( eid, econn, num_conn, true );
    MB_CHK_ERR( error );
 
    EntityHandle v_start = econn[0], v_end = econn[1];
    int v1idx = ID_FROM_HANDLE( v_start ) - 1;
    int v2idx = ID_FROM_HANDLE( v_end ) - 1;
 
    // Find an half-facets incident to each end vertex of the edge
    std::vector< EntityHandle > start_cells;
    HFacet hf1 = v2hf[v1idx];
    HFacet hf2 = v2hf[v2idx];
 
    if( hf1 == 0 && !v2hfs.empty() )
    {
        std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
            it_hes;
        it_hes = v2hfs.equal_range( v_start );
 
        for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
        {
            start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
        }
    }
    else if( hf1 != 0 )
    {
        start_cells.push_back( fid_from_halfacet( hf1, ctype ) );
    }
 
    if( hf2 == 0 && !v2hfs.empty() )
    {
        std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
            it_hes;
        it_hes = v2hfs.equal_range( v_end );
 
        for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
        {
            start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
        }
    }
    else if( hf2 != 0 )
    {
        start_cells.push_back( fid_from_halfacet( hf2, ctype ) );
    }
 
    if( start_cells.empty() ) return MB_SUCCESS;
 
    std::sort( start_cells.begin(), start_cells.end() );
    std::vector< EntityHandle >::iterator last = std::unique( start_cells.begin(), start_cells.end() );
    start_cells.erase( last, start_cells.end() );
 
    for( int i = 0; i < (int)start_cells.size(); i++ )
        cellq[i] = start_cells[i];
 
    int qsize     = start_cells.size();
    int num_qvals = 0;
 
    while( num_qvals < qsize )
    {
        EntityHandle cell_id = cellq[num_qvals];
        num_qvals += 1;
 
        const EntityHandle* conn;
        error = mb->get_connectivity( cell_id, conn, nvpc, true );
        MB_CHK_ERR( error );
 
        int lv0 = -1, lv1 = -1, lv = -1;
 
        // locate v_origin in poped out tet, check if v_end is in
        for( int i = 0; i < nvpc; i++ )
        {
            if( v_start == conn[i] )
            {
                lv0 = i;
                lv  = lv0;
            }
            else if( v_end == conn[i] )
            {
                lv1 = i;
                lv  = lv1;
            }
        }
 
        if( ( lv0 >= 0 ) && ( lv1 >= 0 ) )
        {
            adjents.push_back( cell_id );
            if( leids != NULL ) leids->push_back( lConnMap3D[index].lookup_leids[lv0][lv1] );
        }
 
        // push back new found unchecked incident tets of v_start
        int cidx = ID_FROM_HANDLE( cell_id ) - 1;
        if( lv < 0 ) MB_SET_ERR( MB_FAILURE, "did not find local vertex " );
        int nhf_thisv = lConnMap3D[index].v2hf_num[lv];
 
        for( int i = 0; i < nhf_thisv; i++ )
        {
            int ind          = lConnMap3D[index].v2hf[lv][i];
            HFacet hf        = sibhfs[nfpc * cidx + ind];
            EntityHandle ngb = fid_from_halfacet( hf, ctype );
 
            if( ngb )
            {
                bool found_ent = find_match_in_array( ngb, &cellq[0], qsize - 1 );
 
                if( !found_ent )
                {
                    cellq[qsize] = ngb;
                    qsize += 1;
                }
            }
        }
    }
 
    for( int i = 0; i < qsize; i++ )
        cellq[i] = 0;
 
    return MB_SUCCESS;
}

References _cells, moab::Range::begin(), cellq, moab::error(), ErrorCode, fid_from_halfacet(), find_match_in_array(), moab::Core::get_connectivity(), get_index_in_lmap(), moab::ID_FROM_HANDLE(), moab::index, lConnMap3D, mb, MB_CHK_ERR, MB_SET_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps3D::num_verts_in_cell, sibhfs, moab::Core::type_from_handle(), moab::HalfFacetRep::LocalMaps3D::v2hf, v2hf, moab::HalfFacetRep::LocalMaps3D::v2hf_num, and v2hfs.

Referenced by moab::NestedRefine::construct_hm_1D(), find_total_edges_faces_3d(), get_half_facet_in_comp(), get_up_adjacencies(), moab::NestedRefine::is_edge_on_boundary(), and moab::NestedRefine::update_tracking_verts().

get_up_adjacencies_edg_3d_comp()

ErrorCode moab::HalfFacetRep::get_up_adjacencies_edg_3d_comp	(	EntityHandle	cid,
		int	leid,
		std::vector< EntityHandle > &	adjents,
		std::vector< int > *	leids = NULL,
		std::vector< int > *	adj_orients = NULL
	)

Definition at line 2563 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityType ctype = mb->type_from_handle( cid );
    int index        = get_index_in_lmap( cid );
    int nvpc         = lConnMap3D[index].num_verts_in_cell;
    int nfpc         = lConnMap3D[index].num_faces_in_cell;
    adjents.clear();
    adjents.reserve( 20 );
 
    if( leids != NULL )
    {
        leids->clear();
        leids->reserve( 20 );
    }
    if( adj_orients != NULL )
    {
        adj_orients->clear();
        adj_orients->reserve( 20 );
    }
 
    const EntityHandle* econn;
    error = mb->get_connectivity( cid, econn, nvpc );
    MB_CHK_ERR( error );
 
    // Get the end vertices of the edge <cid,leid>
    int id               = lConnMap3D[index].e2v[leid][0];
    EntityHandle v_start = econn[id];
    id                   = lConnMap3D[index].e2v[leid][1];
    EntityHandle v_end   = econn[id];
 
    int v1idx = ID_FROM_HANDLE( v_start ) - 1;
    int v2idx = ID_FROM_HANDLE( v_end ) - 1;
 
    // Find an half-facets incident to each end vertex of the edge
    std::vector< EntityHandle > start_cells;
    HFacet hf1 = v2hf[v1idx];
    HFacet hf2 = v2hf[v2idx];
 
    if( ( hf1 == 0 ) && ( v2hfs.find( v_start ) != v2hfs.end() ) && ( hf2 == 0 ) &&
        ( v2hfs.find( v_end ) != v2hfs.end() ) )
    {
        std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
            it_hes;
        it_hes = v2hfs.equal_range( v_start );
 
        for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
        {
            start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
        }
    }
    else
        return MB_SUCCESS;
 
    if( start_cells.empty() ) return MB_SUCCESS;
 
    // std::sort(start_cells.begin(), start_cells.end());
    //  std::vector<EntityHandle>::iterator last = std::unique(start_cells.begin(),
    //  start_cells.end()); start_cells.erase(last, start_cells.end());
 
    for( int c = 0; c < (int)start_cells.size(); c++ )
    {
        cellq[0] = start_cells[c];
 
        int qsize     = 1;
        int num_qvals = 0;
 
        while( num_qvals < qsize )
        {
            EntityHandle cell_id = cellq[num_qvals];
            num_qvals += 1;
 
            const EntityHandle* conn;
            error = mb->get_connectivity( cell_id, conn, nvpc );
            MB_CHK_ERR( error );
 
            int lv0 = -1, lv1 = -1, lv = -1;
 
            // locate v_origin in poped out tet, check if v_end is in
            for( int i = 0; i < nvpc; i++ )
            {
                if( v_start == conn[i] )
                {
                    lv0 = i;
                    lv  = lv0;
                }
                else if( v_end == conn[i] )
                {
                    lv1 = i;
                    lv  = lv1;
                }
            }
 
            if( ( lv0 >= 0 ) && ( lv1 >= 0 ) )
            {
                adjents.push_back( cell_id );
                if( leids != NULL ) leids->push_back( lConnMap3D[index].lookup_leids[lv0][lv1] );
 
                if( adj_orients != NULL )
                {
                    int cur_leid = lConnMap3D[index].lookup_leids[lv0][lv1];
                    int id1      = lConnMap3D[index].e2v[cur_leid][0];
                    int id2      = lConnMap3D[index].e2v[cur_leid][1];
                    if( ( v_start == conn[id1] ) && ( v_end == conn[id2] ) )
                        adj_orients->push_back( 1 );
                    else if( ( v_start == conn[id2] ) && ( v_end == conn[id1] ) )
                        adj_orients->push_back( 0 );
                }
 
                for( int i = 0; i < qsize; i++ )
                    cellq[i] = 0;
 
                break;
            }
 
            // push back new found unchecked incident tets of v_start
            int cidx      = ID_FROM_HANDLE( cell_id ) - 1;
            int nhf_thisv = lConnMap3D[index].v2hf_num[lv];
 
            for( int i = 0; i < nhf_thisv; i++ )
            {
                int ind          = lConnMap3D[index].v2hf[lv][i];
                HFacet hf        = sibhfs[nfpc * cidx + ind];
                EntityHandle ngb = fid_from_halfacet( hf, ctype );
 
                if( ngb )
                {
                    bool found_ent = find_match_in_array( ngb, &cellq[0], qsize - 1 );
 
                    if( !found_ent )
                    {
                        cellq[qsize] = ngb;
                        qsize += 1;
                    }
                }
            }
        }
 
        for( int i = 0; i < qsize; i++ )
            cellq[i] = 0;
    }
 
    return MB_SUCCESS;
}

References cellq, moab::HalfFacetRep::LocalMaps3D::e2v, moab::error(), ErrorCode, fid_from_halfacet(), find_match_in_array(), moab::Core::get_connectivity(), get_index_in_lmap(), moab::ID_FROM_HANDLE(), moab::index, lConnMap3D, moab::HalfFacetRep::LocalMaps3D::lookup_leids, mb, MB_CHK_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps3D::num_verts_in_cell, sibhfs, moab::Core::type_from_handle(), moab::HalfFacetRep::LocalMaps3D::v2hf, v2hf, moab::HalfFacetRep::LocalMaps3D::v2hf_num, and v2hfs.

Referenced by moab::NestedRefine::update_global_ahf_3D().

get_up_adjacencies_face_3d() [1/2]

ErrorCode moab::HalfFacetRep::get_up_adjacencies_face_3d	(	EntityHandle	cid,
		int	lfid,
		std::vector< EntityHandle > &	adjents,
		std::vector< int > *	lfids = NULL
	)

Given a local face <cid, lfid>, finds the cells incident on it.

Given a local face, it gathers all the incident cells via the sibhfs map.

Parameters

cid	EntityHandle of the cell containing the local edge
lfid	local face id w.r.t the cell
adjents	Vector returning the incident cells
local_id	By default false. If true, returns the local face id's corresponding to the input face
lfids	Vector returning local face ids

Definition at line 2731 of file HalfFacetRep.cpp.

{
 
    EntityHandle start_cell = *_cells.begin();
    EntityType ctype        = mb->type_from_handle( start_cell );
    int index               = get_index_in_lmap( start_cell );
    int nfpc                = lConnMap3D[index].num_faces_in_cell;
 
    adjents.reserve( 4 );
    adjents.push_back( cid );
 
    if( lfids != NULL )
    {
        lfids->reserve( 4 );
        lfids->push_back( lfid );
    }
 
    int cidx            = ID_FROM_HANDLE( cid ) - 1;
    HFacet hf           = sibhfs[nfpc * cidx + lfid];
    EntityHandle sibcid = fid_from_halfacet( hf, ctype );
    int siblid          = lid_from_halffacet( hf );
 
    if( sibcid != 0 )
    {
        adjents.push_back( sibcid );
        if( lfids != NULL ) lfids->push_back( siblid );
    }
 
    return MB_SUCCESS;
}

References _cells, moab::Range::begin(), fid_from_halfacet(), get_index_in_lmap(), moab::ID_FROM_HANDLE(), moab::index, lConnMap3D, lid_from_halffacet(), mb, MB_SUCCESS, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, sibhfs, and moab::Core::type_from_handle().

get_up_adjacencies_face_3d() [2/2]

ErrorCode moab::HalfFacetRep::get_up_adjacencies_face_3d	(	EntityHandle	fid,
		std::vector< EntityHandle > &	adjents,
		std::vector< int > *	lfids = NULL
	)

Given an face, finds the cells incident on it.

Given an face, it first finds a matching half-face in a cell corresponding to face, and then collects all the incident cells via the sibhfs map.

Parameters

fid	EntityHandle of the query face
adjents	Vector returning the incident cells
local_id	By default false. If true, returns the local face id's corresponding to the input face
leids	Vector returning local face ids

Definition at line 2712 of file HalfFacetRep.cpp.

{
    ErrorCode error;
 
    EntityHandle cid = 0;
    int lid          = 0;
    bool found       = find_matching_halfface( fid, &cid, &lid );
 
    if( found )
    {
        error = get_up_adjacencies_face_3d( cid, lid, adjents, lfids );
        MB_CHK_ERR( error );
    }
 
    return MB_SUCCESS;
}

References moab::error(), ErrorCode, find_matching_halfface(), MB_CHK_ERR, and MB_SUCCESS.

Referenced by moab::NestedRefine::construct_hm_2D(), find_total_edges_faces_3d(), get_up_adjacencies(), moab::NestedRefine::is_face_on_boundary(), and moab::NestedRefine::update_tracking_verts().

get_up_adjacencies_vert_2d()

ErrorCode moab::HalfFacetRep::get_up_adjacencies_vert_2d	(	EntityHandle	vid,
		std::vector< EntityHandle > &	adjents
	)

Given a vertex, finds the faces incident on it.

Given a vertex, it first finds an incident half-edge via v2he map, and then collects all the incident half-edges/faces via the sibhes map.

Parameters

vid	EntityHandle of the query vertex
adjents	Vector returning the incident faces

Definition at line 1158 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityType ftype = mb->type_from_handle( *_faces.begin() );
 
    int vidx  = ID_FROM_HANDLE( vid ) - 1;
    HFacet hf = v2he[vidx];
 
    std::vector< EntityHandle > start_fids;
    std::vector< int > start_lids;
 
    if( hf == 0 && ( v2hes.find( vid ) != v2hes.end() ) )
    {
        std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
            it_hes;
        it_hes = v2hes.equal_range( vid );
 
        for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
        {
            start_fids.push_back( fid_from_halfacet( it->second, ftype ) );
            start_lids.push_back( lid_from_halffacet( it->second ) );
        }
    }
    else if( hf != 0 )
    {
        start_fids.push_back( fid_from_halfacet( hf, ftype ) );
        start_lids.push_back( lid_from_halffacet( hf ) );
    }
 
    if( start_fids.empty() ) return MB_SUCCESS;
 
    int qsize = 0, count = -1;
    int num_qvals = 0;
 
    adjents.reserve( (int)start_fids.size() );
 
    for( int i = 0; i < (int)start_fids.size(); i++ )
    {
        adjents.push_back( start_fids[i] );
        error = gather_halfedges( vid, start_fids[i], start_lids[i], &qsize, &count );
        MB_CHK_ERR( error );
    }
 
    while( num_qvals < qsize )
    {
        EntityHandle curfid = queue_fid[num_qvals];
        int curlid          = queue_lid[num_qvals];
        num_qvals += 1;
 
        EntityHandle he2_fid = 0;
        int he2_lid          = 0;
        error                = another_halfedge( vid, curfid, curlid, &he2_fid, &he2_lid );
        MB_CHK_ERR( error );
 
        bool val = find_match_in_array( he2_fid, trackfaces, count );
 
        if( val ) continue;
 
        count += 1;
        trackfaces[count] = he2_fid;
 
        error = get_up_adjacencies_2d( he2_fid, he2_lid, &qsize, &count );
        MB_CHK_ERR( error );
 
        adjents.push_back( he2_fid );
    }
 
    // Change the visited faces to false, also empty the queue
    for( int i = 0; i <= qsize; i++ )
    {
        queue_fid[i] = 0;
        queue_lid[i] = 0;
    }
 
    for( int i = 0; i <= count; i++ )
        trackfaces[i] = 0;
 
    return MB_SUCCESS;
}

References _faces, another_halfedge(), moab::Range::begin(), moab::error(), ErrorCode, fid_from_halfacet(), find_match_in_array(), gather_halfedges(), get_up_adjacencies_2d(), moab::ID_FROM_HANDLE(), lid_from_halffacet(), mb, MB_CHK_ERR, MB_SUCCESS, queue_fid, queue_lid, trackfaces, moab::Core::type_from_handle(), v2he, and v2hes.

Referenced by get_down_adjacencies_face_3d(), get_up_adjacencies(), moab::NestedRefine::vertex_to_entities_down(), and moab::NestedRefine::vertex_to_entities_up().

get_up_adjacencies_vert_3d()

ErrorCode moab::HalfFacetRep::get_up_adjacencies_vert_3d	(	EntityHandle	vid,
		std::vector< EntityHandle > &	adjents
	)

Given a vertex, finds the cells incident on it.

Given a vertex, it first finds an incident half-face via v2hf map, and then collects all the incident half-faces via the sibhfs map.

Parameters

vid	EntityHandle of the query vertex
adjents	Vector returning the incident cells

Definition at line 2175 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    adjents.reserve( 20 );
    EntityType ctype = mb->type_from_handle( *_cells.begin() );
 
    // Obtain a half-face/s incident on v
    int vidx  = ID_FROM_HANDLE( vid ) - 1;
    HFacet hf = v2hf[vidx];
 
    std::vector< EntityHandle > start_cells;
    if( hf == 0 && ( v2hfs.find( vid ) != v2hfs.end() ) )  // Vertex is non-manifold
    {
        std::pair< std::multimap< EntityHandle, HFacet >::iterator, std::multimap< EntityHandle, HFacet >::iterator >
            it_hes;
        it_hes = v2hfs.equal_range( vid );
 
        for( std::multimap< EntityHandle, HFacet >::iterator it = it_hes.first; it != it_hes.second; ++it )
        {
            start_cells.push_back( fid_from_halfacet( it->second, ctype ) );
        }
    }
    else if( hf != 0 )
        start_cells.push_back( fid_from_halfacet( hf, ctype ) );
 
    if( start_cells.empty() ) return MB_SUCCESS;
 
    int index = get_index_in_lmap( start_cells[0] );
    int nvpc  = lConnMap3D[index].num_verts_in_cell;
    int nfpc  = lConnMap3D[index].num_faces_in_cell;
 
    for( int i = 0; i < (int)start_cells.size(); i++ )
        cellq[i] = start_cells[i];
 
    int qsize = start_cells.size();
    EntityHandle cur_cid;
    int num_qvals = 0;
 
    while( num_qvals < qsize )
    {
        cur_cid = cellq[num_qvals];
        num_qvals += 1;
 
        // Add the current cell to output adj vector
        adjents.push_back( cur_cid );
 
        // Connectivity of the cell
        const EntityHandle* conn;
        error = mb->get_connectivity( cur_cid, conn, nvpc, true );
        MB_CHK_ERR( error );
 
        // Local id of vid in the cell and the half-faces incident on it
        int lv = -1;
        for( int i = 0; i < nvpc; ++i )
        {
            if( conn[i] == vid )
            {
                lv = i;
                break;
            }
        };
        if( lv < 0 ) MB_SET_ERR( MB_FAILURE, "did not find local vertex " );
        // Number of local half-faces incident on the current vertex
        int nhf_thisv = lConnMap3D[index].v2hf_num[lv];
        int cidx      = ID_FROM_HANDLE( cur_cid ) - 1;
 
        // Add new cells into the stack
        EntityHandle ngb;
        for( int i = 0; i < nhf_thisv; ++i )
        {
            int ind = lConnMap3D[index].v2hf[lv][i];
            hf      = sibhfs[nfpc * cidx + ind];
            ngb     = fid_from_halfacet( hf, ctype );
 
            if( ngb )
            {
                bool found_ent = find_match_in_array( ngb, cellq, qsize - 1 );
 
                if( !found_ent )
                {
                    cellq[qsize] = ngb;
                    qsize += 1;
                }
            }
        }
    }
 
    // Change the visited faces to false
    for( int i = 0; i < qsize; i++ )
        cellq[i] = 0;
 
    return MB_SUCCESS;
}

References _cells, moab::Range::begin(), cellq, moab::error(), ErrorCode, fid_from_halfacet(), find_match_in_array(), moab::Core::get_connectivity(), get_index_in_lmap(), moab::ID_FROM_HANDLE(), moab::index, lConnMap3D, mb, MB_CHK_ERR, MB_SET_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps3D::num_verts_in_cell, sibhfs, moab::Core::type_from_handle(), moab::HalfFacetRep::LocalMaps3D::v2hf, v2hf, moab::HalfFacetRep::LocalMaps3D::v2hf_num, and v2hfs.

Referenced by get_up_adjacencies(), moab::NestedRefine::vertex_to_entities_down(), and moab::NestedRefine::vertex_to_entities_up().

init_curve()

ErrorCode moab::HalfFacetRep::init_curve ( )

protected

Definition at line 310 of file HalfFacetRep.cpp.

{
    ErrorCode error;
 
    int nv = ID_FROM_HANDLE( *( _verts.end() - 1 ) );
    int ne = ID_FROM_HANDLE( *( _edges.end() - 1 ) );
 
    v2hv.resize( nv, 0 );
    sibhvs.resize( ne * 2, 0 );
 
    error = determine_sibling_halfverts( _verts, _edges );
    MB_CHK_ERR( error );
    error = determine_incident_halfverts( _edges );
    MB_CHK_ERR( error );
 
    return MB_SUCCESS;
}

References _edges, _verts, determine_incident_halfverts(), determine_sibling_halfverts(), moab::Range::end(), moab::error(), ErrorCode, moab::ID_FROM_HANDLE(), MB_CHK_ERR, MB_SUCCESS, sibhvs, and v2hv.

Referenced by initialize().

init_surface()

ErrorCode moab::HalfFacetRep::init_surface ( )

protected

Definition at line 328 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityType ftype = mb->type_from_handle( *_faces.begin() );
    int nepf         = lConnMap2D[ftype - 2].num_verts_in_face;
 
    int nv = ID_FROM_HANDLE( *( _verts.end() - 1 ) );
    int nf = ID_FROM_HANDLE( *( _faces.end() - 1 ) );
 
    v2he.resize( nv, 0 );
    sibhes.resize( nf * nepf, 0 );
 
    // Construct ahf maps
    error = determine_sibling_halfedges( _faces );
    MB_CHK_ERR( error );
    error = determine_incident_halfedges( _faces );
    MB_CHK_ERR( error );
 
    // Initialize queues for storing face and local id's during local search
    for( int i = 0; i < MAXSIZE; i++ )
    {
        queue_fid[i]  = 0;
        queue_lid[i]  = 0;
        trackfaces[i] = 0;
    }
 
    return MB_SUCCESS;
}

References _faces, _verts, moab::Range::begin(), determine_incident_halfedges(), determine_sibling_halfedges(), moab::Range::end(), moab::error(), ErrorCode, moab::ID_FROM_HANDLE(), lConnMap2D, moab::MAXSIZE, mb, MB_CHK_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, queue_fid, queue_lid, sibhes, trackfaces, moab::Core::type_from_handle(), and v2he.

Referenced by initialize().

init_volume()

ErrorCode moab::HalfFacetRep::init_volume ( )

protected

Definition at line 357 of file HalfFacetRep.cpp.

{
    ErrorCode error;
 
    // Initialize std::map between cell-types and their index in lConnMap3D
    cell_index[MBTET]     = 0;
    cell_index[MBPYRAMID] = 1;
    cell_index[MBPRISM]   = 2;
    cell_index[MBHEX]     = 3;
 
    int index = get_index_in_lmap( *_cells.begin() );
    int nfpc  = lConnMap3D[index].num_faces_in_cell;
    int nv    = ID_FROM_HANDLE( *( _verts.end() - 1 ) );
    int nc    = ID_FROM_HANDLE( *( _cells.end() - 1 ) );
    ;
 
    v2hf.resize( nv, 0 );
    sibhfs.resize( nc * nfpc, 0 );
 
    // Construct the maps
    error = determine_sibling_halffaces( _cells );
    MB_CHK_ERR( error );
    error = determine_incident_halffaces( _cells );
    MB_CHK_ERR( error );
 
    // Initialize queues for storing face and local id's during local search
    for( int i = 0; i < MAXSIZE; i++ )
    {
        Stkcells[i]   = 0;
        cellq[i]      = 0;
        trackcells[i] = 0;
    }
 
    return MB_SUCCESS;
}

References _cells, _verts, moab::Range::begin(), cell_index, cellq, determine_incident_halffaces(), determine_sibling_halffaces(), moab::Range::end(), moab::error(), ErrorCode, get_index_in_lmap(), moab::ID_FROM_HANDLE(), moab::index, lConnMap3D, moab::MAXSIZE, MB_CHK_ERR, MB_SUCCESS, MBHEX, MBPRISM, MBPYRAMID, MBTET, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, sibhfs, Stkcells, trackcells, and v2hf.

Referenced by initialize().

initialize()

ErrorCode moab::HalfFacetRep::initialize

(

)

Constructs the sibling-half-facet and vertex-to-incident-half-facet maps for each dimension present in the input. This routine should be called before any calls for adjacency is made.

Definition at line 194 of file HalfFacetRep.cpp.

{
    ErrorCode error;
 
    if( !mInitAHFmaps )
    {
        mInitAHFmaps = true;
#ifdef MOAB_HAVE_MPI
        if( pcomm && _filterghost )
        {
            moab::Range _averts, _aedgs, _afacs, _acels;
            error = mb->get_entities_by_dimension( this->_rset, 0, _averts, true );
            MB_CHK_ERR( error );
            error = mb->get_entities_by_dimension( this->_rset, 1, _aedgs, true );
            MB_CHK_ERR( error );
            error = mb->get_entities_by_dimension( this->_rset, 2, _afacs, true );
            MB_CHK_ERR( error );
            error = mb->get_entities_by_dimension( this->_rset, 3, _acels, true );
            MB_CHK_ERR( error );
 
            // filter based on parallel status
            error = pcomm->filter_pstatus( _averts, PSTATUS_GHOST, PSTATUS_NOT, -1, &_verts );
            MB_CHK_ERR( error );
            error = pcomm->filter_pstatus( _aedgs, PSTATUS_GHOST, PSTATUS_NOT, -1, &_edges );
            MB_CHK_ERR( error );
            error = pcomm->filter_pstatus( _afacs, PSTATUS_GHOST, PSTATUS_NOT, -1, &_faces );
            MB_CHK_ERR( error );
            error = pcomm->filter_pstatus( _acels, PSTATUS_GHOST, PSTATUS_NOT, -1, &_cells );
            MB_CHK_ERR( error );
        }
        else
        {
            error = mb->get_entities_by_dimension( this->_rset, 0, _verts, true );
            MB_CHK_ERR( error );
            error = mb->get_entities_by_dimension( this->_rset, 1, _edges, true );
            MB_CHK_ERR( error );
            error = mb->get_entities_by_dimension( this->_rset, 2, _faces, true );
            MB_CHK_ERR( error );
            error = mb->get_entities_by_dimension( this->_rset, 3, _cells, true );
            MB_CHK_ERR( error );
        }
#else
        error = mb->get_entities_by_dimension( this->_rset, 0, _verts, true );
        MB_CHK_ERR( error );
        error = mb->get_entities_by_dimension( this->_rset, 1, _edges, true );
        MB_CHK_ERR( error );
        error = mb->get_entities_by_dimension( this->_rset, 2, _faces, true );
        MB_CHK_ERR( error );
        error = mb->get_entities_by_dimension( this->_rset, 3, _cells, true );
        MB_CHK_ERR( error );
 
#endif
 
        int nverts = _verts.size();
        int nedges = _edges.size();
        int nfaces = _faces.size();
        int ncells = _cells.size();
 
        MESHTYPE mesh_type = get_mesh_type( nverts, nedges, nfaces, ncells );
        thismeshtype       = mesh_type;
 
        // Initialize mesh type specific maps
        if( thismeshtype == CURVE )
        {
            error = init_curve();
            MB_CHK_ERR( error );
        }
        else if( thismeshtype == SURFACE )
        {
            error = init_surface();
            MB_CHK_ERR( error );
        }
        else if( thismeshtype == SURFACE_MIXED )
        {
            error = init_curve();
            MB_CHK_ERR( error );
            error = init_surface();
            MB_CHK_ERR( error );
        }
        else if( thismeshtype == VOLUME )
        {
            error = init_volume();
            MB_CHK_ERR( error );
        }
        else if( thismeshtype == VOLUME_MIXED_1 )
        {
            error = init_curve();
            MB_CHK_ERR( error );
            error = init_volume();
            MB_CHK_ERR( error );
        }
        else if( thismeshtype == VOLUME_MIXED_2 )
        {
            error = init_surface();
            MB_CHK_ERR( error );
            error = init_volume();
            MB_CHK_ERR( error );
        }
        else if( thismeshtype == VOLUME_MIXED )
        {
            error = init_curve();
            MB_CHK_ERR( error );
            error = init_surface();
            MB_CHK_ERR( error );
            error = init_volume();
            MB_CHK_ERR( error );
        }
    }
    return MB_SUCCESS;
}

References _cells, _edges, _faces, _filterghost, _rset, _verts, moab::CURVE, moab::error(), ErrorCode, moab::ParallelComm::filter_pstatus(), moab::Core::get_entities_by_dimension(), get_mesh_type(), init_curve(), init_surface(), init_volume(), mb, MB_CHK_ERR, MB_SUCCESS, mInitAHFmaps, pcomm, PSTATUS_GHOST, PSTATUS_NOT, moab::Range::size(), moab::SURFACE, moab::SURFACE_MIXED, thismeshtype, moab::VOLUME, moab::VOLUME_MIXED, moab::VOLUME_MIXED_1, and moab::VOLUME_MIXED_2.

Referenced by get_adjacencies(), moab::NestedRefine::initialize(), and moab::HiReconstruction::initialize().

lid_from_halffacet()

int moab::HalfFacetRep::lid_from_halffacet

(

const HFacet

facet

)

Definition at line 3841 of file HalfFacetRep.cpp.

{
    if( facet == 0 )
        return 0;
    else
        return LID_FROM_HALFFACET( facet );
}

References moab::LID_FROM_HALFFACET().

Referenced by find_matching_halfedge(), get_half_facet_in_comp(), get_incident_map(), get_neighbor_adjacencies_1d(), get_sibling_map(), get_up_adjacencies_1d(), get_up_adjacencies_2d(), get_up_adjacencies_face_3d(), get_up_adjacencies_vert_2d(), and print_tags().

mark_halfedges()

ErrorCode moab::HalfFacetRep::mark_halfedges ( EntityHandle  vid, EntityHandle  he_fid, int  he_lid, Range &  faces, std::vector< char > &  markHEdgs, HFacet &  bnd_hf  )

protected

Definition at line 1084 of file HalfFacetRep.cpp.

{
    ErrorCode error;
    EntityType ftype = mb->type_from_handle( he_fid );
    int nepf         = lConnMap2D[ftype - 2].num_verts_in_face;
 
    int qsize = 0, count = -1;
    int num_qvals = 0;
 
    error = gather_halfedges( vid, he_fid, he_lid, &qsize, &count );
    MB_CHK_ERR( error );
 
    while( num_qvals < qsize )
    {
        EntityHandle curfid = queue_fid[num_qvals];
        int curlid          = queue_lid[num_qvals];
        num_qvals += 1;
 
        int fidx = ID_FROM_HANDLE( curfid ) - 1;
 
        const EntityHandle* conn;
        error = mb->get_connectivity( curfid, conn, nepf, true );
        MB_CHK_ERR( error );
 
        if( !markHEdgs[nepf * faces.index( curfid ) + curlid] && ( conn[curlid] == vid ) )
        {
            markHEdgs[nepf * faces.index( curfid ) + curlid] = 1;
            HFacet hf                                        = sibhes[nepf * fidx + curlid];
            EntityHandle sibfid                              = fid_from_halfacet( hf, ftype );
            if( sibfid == 0 ) bnd_hf = create_halffacet( curfid, curlid );
        }
 
        EntityHandle he2_fid = 0;
        int he2_lid          = 0;
        error                = another_halfedge( vid, curfid, curlid, &he2_fid, &he2_lid );
        MB_CHK_ERR( error );
 
        if( !markHEdgs[nepf * faces.index( curfid ) + he2_lid] && ( conn[he2_lid] == vid ) )
        {
            markHEdgs[nepf * faces.index( curfid ) + he2_lid] = 1;
            HFacet hf                                         = sibhes[nepf * fidx + he2_lid];
            EntityHandle sibfid                               = fid_from_halfacet( hf, ftype );
            if( sibfid == 0 ) bnd_hf = create_halffacet( he2_fid, he2_lid );
        }
 
        bool val = find_match_in_array( he2_fid, trackfaces, count );
 
        if( val ) continue;
 
        count += 1;
        trackfaces[count] = he2_fid;
 
        error = get_up_adjacencies_2d( he2_fid, he2_lid, &qsize, &count );
        MB_CHK_ERR( error );
    }
 
    // Change the visited faces to false, also empty the queue
    for( int i = 0; i <= qsize; i++ )
    {
        queue_fid[i] = 0;
        queue_lid[i] = 0;
    }
 
    for( int i = 0; i <= count; i++ )
        trackfaces[i] = 0;
    return MB_SUCCESS;
}

References another_halfedge(), create_halffacet(), moab::error(), ErrorCode, fid_from_halfacet(), find_match_in_array(), gather_halfedges(), moab::Core::get_connectivity(), get_up_adjacencies_2d(), moab::ID_FROM_HANDLE(), moab::Range::index(), lConnMap2D, mb, MB_CHK_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, queue_fid, queue_lid, sibhes, trackfaces, and moab::Core::type_from_handle().

Referenced by determine_incident_halfedges().

print_tags()

ErrorCode moab::HalfFacetRep::print_tags

(

int

dim

)

Prints the tag values.

Definition at line 394 of file HalfFacetRep.cpp.

{
    if( dim == 1 )
    {
        EntityHandle start_edge = *_edges.begin();
        std::cout << "start_edge = " << start_edge << std::endl;
        std::cout << "<SIBHVS_EID,SIBHVS_LVID>" << std::endl;
 
        for( Range::iterator i = _edges.begin(); i != _edges.end(); ++i )
        {
            EntityHandle eid[2];
            int lvid[2];
            int eidx   = ID_FROM_HANDLE( *i ) - 1;
            HFacet hf1 = sibhvs[2 * eidx];
            HFacet hf2 = sibhvs[2 * eidx + 1];
            eid[0]     = fid_from_halfacet( hf1, MBEDGE );
            eid[1]     = fid_from_halfacet( hf2, MBEDGE );
            lvid[0]    = lid_from_halffacet( hf1 );
            lvid[1]    = lid_from_halffacet( hf2 );
            std::cout << "Entity = " << *i << " :: <" << eid[0] << "," << lvid[0] << ">"
                      << "      "
                      << "<" << eid[1] << "," << lvid[1] << ">" << std::endl;
        }
 
        std::cout << "<V2HV_EID, V2HV_LVID>" << std::endl;
 
        for( Range::iterator i = _verts.begin(); i != _verts.end(); ++i )
        {
            int vidx         = ID_FROM_HANDLE( *i ) - 1;
            HFacet hf        = v2hv[vidx];
            EntityHandle eid = fid_from_halfacet( hf, MBEDGE );
            int lvid         = lid_from_halffacet( hf );
            std::cout << "Vertex = " << *i << " :: <" << eid << "," << lvid << ">" << std::endl;
        }
    }
    else if( dim == 2 )
    {
        EntityType ftype        = mb->type_from_handle( *_faces.begin() );
        int nepf                = lConnMap2D[ftype - 2].num_verts_in_face;
        EntityHandle start_face = *_faces.begin();
        std::cout << "start_face = " << start_face << std::endl;
        std::cout << "<SIBHES_FID,SIBHES_LEID>" << std::endl;
 
        for( Range::iterator i = _faces.begin(); i != _faces.end(); ++i )
        {
            int fidx = ID_FROM_HANDLE( *i ) - 1;
            std::cout << "Entity = " << *i;
            for( int j = 0; j < nepf; j++ )
            {
                HFacet hf        = sibhes[nepf * fidx + j];
                EntityHandle sib = fid_from_halfacet( hf, ftype );
                int lid          = lid_from_halffacet( hf );
                std::cout << " :: <" << sib << "," << lid << ">"
                          << "       ";
            }
            std::cout << std::endl;
        }
 
        std::cout << "<V2HE_FID, V2HE_LEID>" << std::endl;
 
        for( Range::iterator i = _verts.begin(); i != _verts.end(); ++i )
        {
            int vidx         = ID_FROM_HANDLE( *i ) - 1;
            HFacet hf        = v2he[vidx];
            EntityHandle fid = fid_from_halfacet( hf, ftype );
            int lid          = lid_from_halffacet( hf );
            std::cout << "Vertex = " << *i << " :: <" << fid << "," << lid << ">" << std::endl;
        }
    }
    else if( dim == 3 )
    {
        EntityType ctype = mb->type_from_handle( *_cells.begin() );
 
        int index               = get_index_in_lmap( *_cells.begin() );
        int nfpc                = lConnMap3D[index].num_faces_in_cell;
        EntityHandle start_cell = *_cells.begin();
        std::cout << "start_cell = " << start_cell << std::endl;
        std::cout << "<SIBHES_CID,SIBHES_LFID>" << std::endl;
 
        for( Range::iterator i = _cells.begin(); i != _cells.end(); ++i )
        {
            int cidx = ID_FROM_HANDLE( *i ) - 1;
            std::cout << "Entity = " << *i;
            for( int j = 0; j < nfpc; j++ )
            {
                HFacet hf        = sibhfs[nfpc * cidx + j];
                EntityHandle sib = fid_from_halfacet( hf, ctype );
                int lid          = lid_from_halffacet( hf );
                std::cout << " :: <" << sib << "," << lid << ">"
                          << "       ";
            }
            std::cout << std::endl;
        }
 
        std::cout << "<V2HF_CID, V2HF_LFID>" << std::endl;
        EntityHandle cid;
        int lid;
 
        for( Range::iterator i = _verts.begin(); i != _verts.end(); ++i )
        {
            int vidx  = ID_FROM_HANDLE( *i ) - 1;
            HFacet hf = v2hf[vidx];
 
            if( hf == 0 && ( v2hfs.find( *i ) != v2hfs.end() ) )
            {
                std::pair< std::multimap< EntityHandle, HFacet >::iterator,
                           std::multimap< EntityHandle, HFacet >::iterator >
                    it_hfs;
                it_hfs = v2hfs.equal_range( *i );
 
                for( std::multimap< EntityHandle, HFacet >::iterator it = it_hfs.first; it != it_hfs.second; ++it )
                {
                    cid = fid_from_halfacet( it->second, ctype );
                    lid = lid_from_halffacet( hf );
 
                    std::cout << "Vertex = " << *i << " :: <" << cid << "," << lid << ">" << std::endl;
                }
            }
            else
            {
                cid = fid_from_halfacet( hf, ctype );
                lid = lid_from_halffacet( hf );
                std::cout << "Vertex = " << *i << " :: <" << cid << "," << lid << ">" << std::endl;
            }
        }
    }
    return MB_SUCCESS;
}

References _cells, _edges, _faces, _verts, moab::Range::begin(), moab::Range::end(), fid_from_halfacet(), get_index_in_lmap(), moab::ID_FROM_HANDLE(), moab::index, lConnMap2D, lConnMap3D, lid_from_halffacet(), mb, MB_SUCCESS, MBEDGE, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, sibhes, sibhfs, sibhvs, moab::Core::type_from_handle(), v2he, v2hf, v2hfs, and v2hv.

resize_hf_maps()

ErrorCode moab::HalfFacetRep::resize_hf_maps	(	EntityHandle	start_vert,
		int	nverts,
		EntityHandle	start_edge,
		int	nedges,
		EntityHandle	start_face,
		int	nfaces,
		EntityHandle	start_cell,
		int	ncells
	)

Definition at line 3402 of file HalfFacetRep.cpp.

{
    int nwsz = 0, insz = 0;
    if( nedges )
    {
        if( ID_FROM_HANDLE( ( *( _edges.end() - 1 ) + 1 ) ) != ID_FROM_HANDLE( start_edge ) )
            nwsz = ( ID_FROM_HANDLE( start_edge ) - ID_FROM_HANDLE( *_edges.end() ) + nedges ) * 2;
        else
            nwsz = nedges * 2;
        insz = sibhvs.size();
        sibhvs.resize( insz + nwsz, 0 );
 
        if( v2hv.empty() )
        {
            if( ( !v2he.empty() ) )
                insz = v2he.size();
            else if( ( !v2hf.empty() ) )
                insz = v2hf.size();
            else
                MB_SET_ERR( MB_FAILURE, "Trying to resize ahf maps for a mesh with no edges, faces and cells" );
        }
        else
            insz = v2hv.size();
 
        if( ID_FROM_HANDLE( *( _verts.end() - 1 ) + 1 ) != ID_FROM_HANDLE( start_vert ) )
            nwsz = ID_FROM_HANDLE( start_vert ) - ID_FROM_HANDLE( *_verts.end() ) + nverts;
        else
            nwsz = nverts;
        v2hv.resize( insz + nwsz, 0 );
    }
 
    if( nfaces )
    {
        EntityType ftype = mb->type_from_handle( *_faces.begin() );
        int nepf         = lConnMap2D[ftype - 2].num_verts_in_face;
 
        if( ID_FROM_HANDLE( ( *( _faces.end() - 1 ) + 1 ) ) != ID_FROM_HANDLE( start_face ) )
            nwsz = ( ID_FROM_HANDLE( start_face ) - ID_FROM_HANDLE( *_faces.end() ) + nfaces ) * nepf;
        else
            nwsz = nfaces * nepf;
        insz = sibhes.size();
        sibhes.resize( insz + nwsz, 0 );
 
        if( ID_FROM_HANDLE( *( _verts.end() - 1 ) + 1 ) != ID_FROM_HANDLE( start_vert ) )
            nwsz = ID_FROM_HANDLE( start_vert ) - ID_FROM_HANDLE( *_verts.end() ) + nverts;
        else
            nwsz = nverts;
        insz = v2he.size();
        v2he.resize( insz + nwsz, 0 );
    }
 
    if( ncells )
    {
        int index = get_index_in_lmap( *_cells.begin() );
        int nfpc  = lConnMap3D[index].num_faces_in_cell;
 
        if( ID_FROM_HANDLE( ( *( _cells.end() - 1 ) + 1 ) ) != ID_FROM_HANDLE( start_cell ) )
            nwsz = ( ID_FROM_HANDLE( start_cell ) - ID_FROM_HANDLE( *_cells.end() ) + ncells ) * nfpc;
        else
            nwsz = ncells * nfpc;
        insz = sibhfs.size();
        sibhfs.resize( insz + nwsz, 0 );
 
        if( ID_FROM_HANDLE( *( _verts.end() - 1 ) + 1 ) != ID_FROM_HANDLE( start_vert ) )
            nwsz = ID_FROM_HANDLE( start_vert ) - ID_FROM_HANDLE( *_verts.end() ) + nverts;
        else
            nwsz = nverts;
        insz = v2hf.size();
        v2hf.resize( insz + nwsz, 0 );
    }
 
    return MB_SUCCESS;
}

References _cells, _edges, _faces, _verts, moab::Range::begin(), moab::Range::end(), get_index_in_lmap(), moab::ID_FROM_HANDLE(), moab::index, lConnMap2D, lConnMap3D, mb, MB_SET_ERR, MB_SUCCESS, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, sibhes, sibhfs, sibhvs, moab::Core::type_from_handle(), v2he, v2hf, and v2hv.

Referenced by moab::NestedRefine::create_hm_storage_single_level().

set_incident_map()

ErrorCode moab::HalfFacetRep::set_incident_map	(	EntityType	type,
		EntityHandle	vid,
		std::vector< EntityHandle > &	set_entid,
		std::vector< int > &	set_lid
	)

Definition at line 3733 of file HalfFacetRep.cpp.

{
    if( type == MBEDGE )
    {
        v2hv[ID_FROM_HANDLE( vid ) - 1] = create_halffacet( set_entid[0], set_lid[0] );
    }
    else if( type == MBTRI || type == MBQUAD )
    {
        if( set_entid.size() == 1 )
            v2he[ID_FROM_HANDLE( vid ) - 1] = create_halffacet( set_entid[0], set_lid[0] );
        else
        {
            HFacet hf = 0;
            for( int i = 0; i < (int)set_entid.size(); i++ )
            {
                hf = create_halffacet( set_entid[i], set_lid[i] );
                v2hes.insert( std::pair< EntityHandle, HFacet >( vid, hf ) );
            }
        }
    }
    else
    {
        if( set_entid.size() == 1 )
            v2hf[ID_FROM_HANDLE( vid ) - 1] = create_halffacet( set_entid[0], set_lid[0] );
        else
        {
            HFacet hf = v2hf[ID_FROM_HANDLE( vid ) - 1];
            if( hf != 0 )
            {
                v2hf[ID_FROM_HANDLE( vid ) - 1] = 0;
            }
            for( int i = 0; i < (int)set_entid.size(); i++ )
            {
                hf = create_halffacet( set_entid[i], set_lid[i] );
                v2hfs.insert( std::pair< EntityHandle, HFacet >( vid, hf ) );
            }
        }
    }
 
    return MB_SUCCESS;
}

References create_halffacet(), moab::ID_FROM_HANDLE(), MB_SUCCESS, MBEDGE, MBQUAD, MBTRI, v2he, v2hes, v2hf, v2hfs, and v2hv.

Referenced by moab::NestedRefine::update_global_ahf_1D(), moab::NestedRefine::update_global_ahf_1D_sub(), moab::NestedRefine::update_global_ahf_2D(), moab::NestedRefine::update_global_ahf_2D_sub(), moab::NestedRefine::update_global_ahf_3D(), and moab::NestedRefine::update_local_ahf().

set_sibling_map() [1/2]

ErrorCode moab::HalfFacetRep::set_sibling_map	(	EntityType	type,
		EntityHandle	ent,
		EntityHandle *	set_entids,
		int *	set_lids,
		int	num_halffacets
	)

Definition at line 3588 of file HalfFacetRep.cpp.

{
 
    if( type == MBEDGE )
    {
        if( num_halffacets != 2 ) MB_SET_ERR( MB_FAILURE, "Incorrect number of halfvertices" );
 
        int eidx = ID_FROM_HANDLE( ent ) - 1;
        for( int i = 0; i < 2; i++ )
        {
            sibhvs[2 * eidx + i] = create_halffacet( set_entids[i], set_lids[i] );
        }
    }
    else if( type == MBTRI || type == MBQUAD )
    {
        int nepf = lConnMap2D[type - 2].num_verts_in_face;
        if( num_halffacets != nepf ) MB_SET_ERR( MB_FAILURE, "Incorrect number of halfedges." );
 
        int fidx = ID_FROM_HANDLE( ent ) - 1;
        for( int i = 0; i < nepf; i++ )
        {
            sibhes[nepf * fidx + i] = create_halffacet( set_entids[i], set_lids[i] );
        }
    }
    else
    {
        int idx  = get_index_in_lmap( *_cells.begin() );
        int nfpc = lConnMap3D[idx].num_faces_in_cell;
        if( num_halffacets != nfpc ) MB_SET_ERR( MB_FAILURE, "Incorrect number of halffaces." );
 
        int cidx = ID_FROM_HANDLE( ent ) - 1;
        for( int i = 0; i < nfpc; i++ )
        {
            sibhfs[nfpc * cidx + i] = create_halffacet( set_entids[i], set_lids[i] );
        }
    }
 
    return MB_SUCCESS;
}

References _cells, moab::Range::begin(), create_halffacet(), get_index_in_lmap(), moab::ID_FROM_HANDLE(), lConnMap2D, lConnMap3D, MB_SET_ERR, MB_SUCCESS, MBEDGE, MBQUAD, MBTRI, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, sibhes, sibhfs, and sibhvs.

Referenced by moab::NestedRefine::update_global_ahf_1D(), moab::NestedRefine::update_global_ahf_1D_sub(), moab::NestedRefine::update_global_ahf_2D(), moab::NestedRefine::update_global_ahf_2D_sub(), moab::NestedRefine::update_global_ahf_3D(), and moab::NestedRefine::update_local_ahf().

set_sibling_map() [2/2]

ErrorCode moab::HalfFacetRep::set_sibling_map	(	EntityType	type,
		EntityHandle	ent,
		int	lid,
		EntityHandle &	set_entid,
		int &	set_lid
	)

Definition at line 3632 of file HalfFacetRep.cpp.

{
 
    if( type == MBEDGE )
    {
        int eidx               = ID_FROM_HANDLE( ent ) - 1;
        sibhvs[2 * eidx + lid] = create_halffacet( set_entid, set_lid );
    }
    else if( type == MBTRI || type == MBQUAD )
    {
        int nepf                  = lConnMap2D[type - 2].num_verts_in_face;
        int fidx                  = ID_FROM_HANDLE( ent ) - 1;
        sibhes[nepf * fidx + lid] = create_halffacet( set_entid, set_lid );
    }
    else
    {
        int idx                   = get_index_in_lmap( *_cells.begin() );
        int nfpc                  = lConnMap3D[idx].num_faces_in_cell;
        int cidx                  = ID_FROM_HANDLE( ent ) - 1;
        sibhfs[nfpc * cidx + lid] = create_halffacet( set_entid, set_lid );
    }
 
    return MB_SUCCESS;
}

References _cells, moab::Range::begin(), create_halffacet(), get_index_in_lmap(), moab::ID_FROM_HANDLE(), lConnMap2D, lConnMap3D, MB_SUCCESS, MBEDGE, MBQUAD, MBTRI, moab::HalfFacetRep::LocalMaps3D::num_faces_in_cell, moab::HalfFacetRep::LocalMaps2D::num_verts_in_face, sibhes, sibhfs, and sibhvs.

update_entity_ranges()

ErrorCode moab::HalfFacetRep::update_entity_ranges

(

EntityHandle

fileset

)

Definition at line 3787 of file HalfFacetRep.cpp.

{
    ErrorCode error;
 
    error = mb->get_entities_by_dimension( fileset, 0, _verts, true );
    MB_CHK_ERR( error );
 
    error = mb->get_entities_by_dimension( fileset, 1, _edges, true );
    MB_CHK_ERR( error );
 
    error = mb->get_entities_by_dimension( fileset, 2, _faces, true );
    MB_CHK_ERR( error );
 
    error = mb->get_entities_by_dimension( fileset, 3, _cells, true );
    MB_CHK_ERR( error );
 
    return MB_SUCCESS;
}

References _cells, _edges, _faces, _verts, moab::error(), ErrorCode, moab::Core::get_entities_by_dimension(), mb, MB_CHK_ERR, and MB_SUCCESS.

Referenced by moab::NestedRefine::create_hm_storage_single_level().

Member Data Documentation

_cells

Range moab::HalfFacetRep::_cells

protected

Definition at line 558 of file HalfFacetRep.hpp.

Referenced by find_matching_halfface(), find_matching_implicit_edge_in_cell(), get_entity_ranges(), get_half_facet_in_comp(), get_sibling_map(), get_up_adjacencies_edg_3d(), get_up_adjacencies_face_3d(), get_up_adjacencies_vert_3d(), init_volume(), initialize(), print_tags(), resize_hf_maps(), set_sibling_map(), and update_entity_ranges().

_edges

Range moab::HalfFacetRep::_edges

protected

Definition at line 558 of file HalfFacetRep.hpp.

Referenced by get_entity_ranges(), init_curve(), initialize(), print_tags(), resize_hf_maps(), and update_entity_ranges().

_faces

Range moab::HalfFacetRep::_faces

protected

Definition at line 558 of file HalfFacetRep.hpp.

Referenced by collect_and_compare(), find_matching_halfedge(), get_entity_ranges(), get_up_adjacencies_vert_2d(), init_surface(), initialize(), print_tags(), resize_hf_maps(), and update_entity_ranges().

_filterghost

bool moab::HalfFacetRep::_filterghost

protected

Definition at line 555 of file HalfFacetRep.hpp.

Referenced by initialize().

_rset

EntityHandle moab::HalfFacetRep::_rset

protected

Definition at line 554 of file HalfFacetRep.hpp.

Referenced by check_mixed_entity_type(), get_rset(), and initialize().

_verts

Range moab::HalfFacetRep::_verts

protected

Definition at line 558 of file HalfFacetRep.hpp.

Referenced by determine_sibling_halfedges(), determine_sibling_halffaces(), get_entity_ranges(), init_curve(), init_surface(), init_volume(), initialize(), print_tags(), resize_hf_maps(), and update_entity_ranges().

adjMatrix

const HalfFacetRep::adj_matrix moab::HalfFacetRep::adjMatrix

staticprotected

Initial value:

= {
    
    
    { { { 0, 1, 0, 0 }, { 1, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } } },
 
    
    { { { 0, 0, 1, 0 }, { 0, 0, 0, 0 }, { 1, 0, 1, 0 }, { 0, 0, 0, 0 } } },
 
    
    { { { 0, 1, 1, 0 }, { 1, 1, 1, 0 }, { 1, 1, 1, 0 }, { 0, 0, 0, 0 } } },
 
    
    { { { 0, 0, 0, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 1, 0, 0, 1 } } },
 
    
    { { { 0, 1, 0, 1 }, { 1, 1, 0, 1 }, { 0, 0, 0, 0 }, { 1, 1, 0, 1 } } },
 
    
    { { { 0, 0, 1, 1 }, { 0, 0, 0, 0 }, { 1, 0, 1, 1 }, { 1, 0, 1, 1 } } },
 
    
    { { { 0, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 } } } }

Definition at line 578 of file HalfFacetRep.hpp.

Referenced by get_adjacencies().

cell_index

std::map< EntityType, int > moab::HalfFacetRep::cell_index

Definition at line 538 of file HalfFacetRep.hpp.

Referenced by get_index_in_lmap(), and init_volume().

cellq

EntityHandle moab::HalfFacetRep::cellq[MAXSIZE]

protected

Definition at line 569 of file HalfFacetRep.hpp.

Referenced by find_matching_implicit_edge_in_cell(), get_up_adjacencies_edg_3d(), get_up_adjacencies_edg_3d_comp(), get_up_adjacencies_vert_3d(), and init_volume().

chk_mixed

bool moab::HalfFacetRep::chk_mixed

protected

Definition at line 583 of file HalfFacetRep.hpp.

Referenced by check_mixed_entity_type(), and HalfFacetRep().

is_mixed

bool moab::HalfFacetRep::is_mixed

protected

Definition at line 582 of file HalfFacetRep.hpp.

Referenced by check_mixed_entity_type(), and HalfFacetRep().

lConnMap2D

const HalfFacetRep::LocalMaps2D moab::HalfFacetRep::lConnMap2D

static

Initial value:

= {
    
    { 3, { 1, 2, 0 }, { 2, 0, 1 } },
    
    { 4, { 1, 2, 3, 0 }, { 3, 0, 1, 2 } } }

Definition at line 503 of file HalfFacetRep.hpp.

Referenced by another_halfedge(), collect_and_compare(), moab::NestedRefine::construct_hm_1D(), moab::NestedRefine::construct_hm_2D(), moab::NestedRefine::create_hm_storage_single_level(), determine_incident_halfedges(), determine_sibling_halfedges(), determine_sibling_halffaces(), find_matching_halfface(), find_total_edges_2d(), moab::NestedRefine::get_connectivity(), get_down_adjacencies_2d(), get_face_edges(), get_neighbor_adjacencies_2d(), get_sibling_map(), get_up_adjacencies_2d(), init_surface(), moab::NestedRefine::is_face_on_boundary(), moab::NestedRefine::is_vertex_on_boundary(), mark_halfedges(), print_tags(), resize_hf_maps(), set_sibling_map(), moab::NestedRefine::update_global_ahf_2D(), moab::NestedRefine::update_global_ahf_2D_sub(), and moab::NestedRefine::update_local_ahf().

lConnMap3D

const HalfFacetRep::LocalMaps3D moab::HalfFacetRep::lConnMap3D

static

Definition at line 535 of file HalfFacetRep.hpp.

Referenced by add_cells_of_single_component(), moab::NestedRefine::construct_hm_1D(), moab::NestedRefine::construct_hm_2D(), moab::NestedRefine::create_hm_storage_single_level(), determine_border_vertices(), determine_incident_halffaces(), determine_sibling_halffaces(), find_matching_halfface(), find_matching_implicit_edge_in_cell(), find_total_edges_faces_3d(), moab::NestedRefine::get_connectivity(), get_down_adjacencies_edg_3d(), get_down_adjacencies_face_3d(), get_half_facet_in_comp(), moab::NestedRefine::get_lid_inci_child(), get_neighbor_adjacencies_3d(), get_sibling_map(), get_up_adjacencies_edg_3d(), get_up_adjacencies_edg_3d_comp(), get_up_adjacencies_face_3d(), get_up_adjacencies_vert_3d(), init_volume(), moab::NestedRefine::is_cell_on_boundary(), moab::NestedRefine::is_edge_on_boundary(), moab::NestedRefine::is_vertex_on_boundary(), print_tags(), moab::NestedRefine::reorder_indices(), resize_hf_maps(), set_sibling_map(), moab::NestedRefine::subdivide_cells(), moab::NestedRefine::subdivide_tets(), moab::NestedRefine::update_global_ahf_3D(), moab::NestedRefine::update_local_ahf(), and moab::NestedRefine::update_tracking_verts().

mb

Core* moab::HalfFacetRep::mb

protected

Definition at line 552 of file HalfFacetRep.hpp.

Referenced by add_cells_of_single_component(), another_halfedge(), check_mixed_entity_type(), collect_and_compare(), determine_border_vertices(), determine_incident_halfedges(), determine_incident_halffaces(), determine_incident_halfverts(), determine_sibling_halfedges(), determine_sibling_halffaces(), determine_sibling_halfverts(), fid_from_halfacet(), find_matching_halfedge(), find_matching_halfface(), find_matching_implicit_edge_in_cell(), find_total_edges_2d(), get_adjacencies(), get_down_adjacencies(), get_down_adjacencies_2d(), get_down_adjacencies_edg_3d(), get_down_adjacencies_face_3d(), get_face_edges(), get_half_facet_in_comp(), get_index_in_lmap(), get_neighbor_adjacencies(), get_neighbor_adjacencies_2d(), get_neighbor_adjacencies_3d(), get_up_adjacencies(), get_up_adjacencies_2d(), get_up_adjacencies_edg_3d(), get_up_adjacencies_edg_3d_comp(), get_up_adjacencies_face_3d(), get_up_adjacencies_vert_2d(), get_up_adjacencies_vert_3d(), init_surface(), initialize(), mark_halfedges(), print_tags(), resize_hf_maps(), and update_entity_ranges().

mInitAHFmaps

bool moab::HalfFacetRep::mInitAHFmaps

protected

Definition at line 556 of file HalfFacetRep.hpp.

Referenced by get_adjacencies(), HalfFacetRep(), and initialize().

pcomm

ParallelComm* moab::HalfFacetRep::pcomm

protected

Definition at line 553 of file HalfFacetRep.hpp.

Referenced by initialize().

queue_fid

EntityHandle moab::HalfFacetRep::queue_fid[MAXSIZE]

protected

Definition at line 569 of file HalfFacetRep.hpp.

Referenced by collect_and_compare(), find_matching_halfedge(), gather_halfedges(), get_up_adjacencies_2d(), get_up_adjacencies_vert_2d(), init_surface(), and mark_halfedges().

queue_lid

int moab::HalfFacetRep::queue_lid[MAXSIZE]

protected

Definition at line 571 of file HalfFacetRep.hpp.

Referenced by collect_and_compare(), find_matching_halfedge(), gather_halfedges(), get_up_adjacencies_2d(), get_up_adjacencies_vert_2d(), init_surface(), and mark_halfedges().

sibhes

std::vector< HFacet > moab::HalfFacetRep::sibhes

protected

Definition at line 562 of file HalfFacetRep.hpp.

Referenced by determine_sibling_halfedges(), get_memory_use(), get_sibling_map(), get_up_adjacencies_2d(), init_surface(), mark_halfedges(), print_tags(), resize_hf_maps(), and set_sibling_map().

sibhfs

std::vector< HFacet > moab::HalfFacetRep::sibhfs

protected

Definition at line 563 of file HalfFacetRep.hpp.

Referenced by add_cells_of_single_component(), determine_border_vertices(), determine_sibling_halffaces(), find_matching_halfface(), find_matching_implicit_edge_in_cell(), get_half_facet_in_comp(), get_memory_use(), get_neighbor_adjacencies_3d(), get_sibling_map(), get_up_adjacencies_edg_3d(), get_up_adjacencies_edg_3d_comp(), get_up_adjacencies_face_3d(), get_up_adjacencies_vert_3d(), init_volume(), print_tags(), resize_hf_maps(), and set_sibling_map().

sibhvs

std::vector< HFacet > moab::HalfFacetRep::sibhvs

protected

Definition at line 561 of file HalfFacetRep.hpp.

Referenced by determine_sibling_halfverts(), get_memory_use(), get_neighbor_adjacencies_1d(), get_sibling_map(), get_up_adjacencies_1d(), init_curve(), print_tags(), resize_hf_maps(), and set_sibling_map().

Stkcells

EntityHandle moab::HalfFacetRep::Stkcells[MAXSIZE]

protected

Definition at line 569 of file HalfFacetRep.hpp.

Referenced by add_cells_of_single_component(), find_matching_halfface(), and init_volume().

thismeshtype

MESHTYPE moab::HalfFacetRep::thismeshtype

Definition at line 536 of file HalfFacetRep.hpp.

Referenced by moab::NestedRefine::construct_hm_entities(), moab::NestedRefine::create_hm_storage_single_level(), get_adjacencies(), and initialize().

trackcells

EntityHandle moab::HalfFacetRep::trackcells[MAXSIZE]

protected

Definition at line 570 of file HalfFacetRep.hpp.

Referenced by add_cells_of_single_component(), find_matching_halfface(), and init_volume().

trackfaces

EntityHandle moab::HalfFacetRep::trackfaces[MAXSIZE]

protected

Definition at line 570 of file HalfFacetRep.hpp.

Referenced by collect_and_compare(), find_matching_halfedge(), gather_halfedges(), get_up_adjacencies_2d(), get_up_adjacencies_vert_2d(), init_surface(), and mark_halfedges().

v2he

std::vector< HFacet > moab::HalfFacetRep::v2he

protected

Definition at line 562 of file HalfFacetRep.hpp.

Referenced by check_nonmanifold_vertices(), determine_incident_halfedges(), find_matching_halfedge(), get_incident_map(), get_memory_use(), get_up_adjacencies_vert_2d(), init_surface(), print_tags(), resize_hf_maps(), and set_incident_map().

v2hes

std::multimap< EntityHandle, HFacet > moab::HalfFacetRep::v2hes

protected

Definition at line 566 of file HalfFacetRep.hpp.

Referenced by check_nonmanifold_vertices(), determine_incident_halfedges(), get_incident_map(), get_up_adjacencies_vert_2d(), and set_incident_map().

v2hf

std::vector< HFacet > moab::HalfFacetRep::v2hf

protected

Definition at line 563 of file HalfFacetRep.hpp.

Referenced by check_nonmanifold_vertices(), determine_incident_halffaces(), find_matching_halfface(), find_matching_implicit_edge_in_cell(), get_incident_map(), get_memory_use(), get_up_adjacencies_edg_3d(), get_up_adjacencies_edg_3d_comp(), get_up_adjacencies_vert_3d(), init_volume(), print_tags(), resize_hf_maps(), and set_incident_map().

v2hfs

std::multimap< EntityHandle, HFacet > moab::HalfFacetRep::v2hfs

protected

Definition at line 566 of file HalfFacetRep.hpp.

Referenced by check_nonmanifold_vertices(), determine_incident_halffaces(), find_matching_halfface(), find_matching_implicit_edge_in_cell(), get_incident_map(), get_up_adjacencies_edg_3d(), get_up_adjacencies_edg_3d_comp(), get_up_adjacencies_vert_3d(), print_tags(), and set_incident_map().

v2hv

std::vector< HFacet > moab::HalfFacetRep::v2hv

protected

Definition at line 561 of file HalfFacetRep.hpp.

Referenced by determine_incident_halfverts(), get_incident_map(), get_memory_use(), get_up_adjacencies_1d(), init_curve(), print_tags(), resize_hf_maps(), and set_incident_map().

---

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

• HalfFacetRep.hpp
• HalfFacetRep.cpp