Class facilitating local discretization-related functionsThis class implements discretization-related functionality operating on data in MOAB. A member of this class caches certain data about the element it's currently operating on, but is not meant to be instantiated one-per-element, but rather one-per-search (or other operation on a collection of elements). More...

#include <ElemEvaluator.hpp>

Collaboration diagram for moab::ElemEvaluator:

Public Member Functions
	ElemEvaluator (Interface *impl, EntityHandle ent=0, Tag tag=0, int tagged_ent_dim=-1)
	Constructor.
	~ElemEvaluator ()
ErrorCode	eval (const double params, double result, int num_tuples=-1) const
	Evaluate cached tag at a given parametric location within the cached entity If evaluating coordinates, call set_tag(0, 0), which indicates coords instead of a tag.
ErrorCode	reverse_eval (const double posn, double iter_tol, double inside_tol, double params, int *is_inside=NULL) const
	Reverse-evaluate the cached entity at a given physical position.
ErrorCode	get_normal (const int ientDim, const int facet, double normal[3]) const
	Evaluate the normal to a facet of an entity.
ErrorCode	jacobian (const double params, double result) const
	Evaluate the jacobian of the cached entity at a given parametric location.
ErrorCode	integrate (double *result) const
	Integrate the cached tag over the cached entity.
int	inside (const double *params, const double tol) const
	Return whether a physical position is inside the cached entity to within a tolerance.
ErrorCode	find_containing_entity (Range &entities, const double point, const double iter_tol, const double inside_tol, EntityHandle &containing_ent, double params, unsigned int *num_evals=NULL)
	Given a list of entities, return the entity the point is in, or none This function reverse-evaluates the entities, returning the first entity containing the point. If no entity contains the point, containing_ent is returned as 0 and params are unchanged. This function returns something other than MB_SUCCESS only when queries go wrong for some reason. num_evals, if non-NULL, is always incremented for each call to reverse_eval. This function calls set_ent_handle for each entity before calling reverse_eval, so the ElemEvaluator object is changed.
ErrorCode	find_containing_entity (EntityHandle ent_set, const double point, const double iter_tol, const double inside_tol, EntityHandle &containing_ent, double params, unsigned int *num_evals=NULL)
	Given an entity set, return the contained entity the point is in, or none This function reverse-evaluates the entities, returning the first entity containing the point. If no entity contains the point, containing_ent is returned as 0 and params are unchanged. This function returns something other than MB_SUCCESS only when queries go wrong for some reason. num_evals, if non-NULL, is always incremented for each call to reverse_eval. This function calls set_ent_handle for each entity before calling reverse_eval, so the ElemEvaluator object is changed.
ErrorCode	set_eval_set (EntityType tp, const EvalSet &eval_set)
	Set the eval set for a given type entity.
ErrorCode	set_eval_set (const EntityHandle eh)
	Set the eval set using a given entity handle This function queries the entity type and number of vertices on the entity to decide which type of shape function to use. NOTE: this function should only be called after setting a valid MOAB instance on the evaluator.
EvalSet	get_eval_set (EntityType tp)
	Get the eval set for a given type entity.
ErrorCode	set_ent_handle (EntityHandle ent)
	Set entity handle & cache connectivty & vertex positions.
EntityHandle	get_ent_handle () const
	Get entity handle for this ElemEval.
double *	get_vert_pos ()
const EntityHandle *	get_vert_handles () const
int	get_num_verts () const
Tag	get_tag_handle () const
ErrorCode	set_tag_handle (Tag tag, int tagged_ent_dim=-1)
ErrorCode	set_tag (const char *tag_name, int tagged_ent_dim=-1)
int	get_tagged_ent_dim () const
ErrorCode	set_tagged_ent_dim (int dim)
double *	get_work_space ()
Interface *	get_moab ()
Private Attributes
Interface *	mbImpl
	Interface.
EntityHandle	entHandle
	Entity handle being evaluated.
EntityType	entType
	Entity type.
int	entDim
	Entity dimension.
int	numVerts
	Number of vertices cached here.
const EntityHandle *	vertHandles
	Cached copy of vertex handle ptr.
CartVect	vertPos [CN::MAX_NODES_PER_ELEMENT]
	Cached copy of vertex positions.
Tag	tagHandle
	Tag being evaluated.
bool	tagCoords
	Whether tag is coordinates or something else.
int	numTuples
	Number of values in this tag.
int	taggedEntDim
	Dimension of entities from which to grab tag.
std::vector< unsigned char >	tagSpace
	Tag space.
EvalSet	evalSets [MBMAXTYPE]
	Evaluation methods for elements of various topologies.
double *	workSpace
	Work space for element-specific data.

Detailed Description

Class facilitating local discretization-related functions

This class implements discretization-related functionality operating on data in MOAB. A member of this class caches certain data about the element it's currently operating on, but is not meant to be instantiated one-per-element, but rather one-per-search (or other operation on a collection of elements).

Actual discretization functionality is accessed through function pointers, allowing applications to specialize the implementation of specific functions while still using this class.

This class depends on MOAB functionality for gathering entity-based data; the functions it calls through function pointers depend only on POD (plain old data, or intrinsic data types). This allows the use of other packages for serving these functions, without having to modify them to get data through MOAB. This should also promote efficiency, since in many cases they will be able to read data from its native storage locations.

Definition at line 177 of file ElemEvaluator.hpp.

Constructor & Destructor Documentation

moab::ElemEvaluator::ElemEvaluator	(	Interface *	impl,
		EntityHandle	ent = `0`,
		Tag	tag = `0`,
		int	tagged_ent_dim = `-1`
	)		`[inline]`

Constructor.

Parameters:

impl	MOAB instance
ent	Entity handle to cache on the evaluator; if non-zero, calls set_ent_handle, which does some other stuff.
tag	Tag to cache on the evaluator; if non-zero, calls set_tag_handle, which does some other stuff too.
tagged_ent_dim	Dimension of entities to be tagged to cache on the evaluator

Definition at line 422 of file ElemEvaluator.hpp.

References set_ent_handle(), and set_tag_handle().

    : mbImpl( impl ), entHandle( 0 ), entType( MBMAXTYPE ), entDim( -1 ), numVerts( 0 ), vertHandles( NULL ),
      tagHandle( 0 ), tagCoords( false ), numTuples( 0 ), taggedEntDim( 0 ), workSpace( NULL )
{
    if( ent ) set_ent_handle( ent );
    if( tag ) set_tag_handle( tag, tagged_ent_dim );
}

moab::ElemEvaluator::~ElemEvaluator ( ) [inline]

Definition at line 430 of file ElemEvaluator.hpp.

References workSpace.

{
    if( workSpace ) delete[] workSpace;
}

Member Function Documentation

ErrorCode moab::ElemEvaluator::eval	(	const double *	params,
		double *	result,
		int	num_tuples = `-1`
	)		const `[inline]`

Evaluate cached tag at a given parametric location within the cached entity If evaluating coordinates, call set_tag(0, 0), which indicates coords instead of a tag.

Parameters:

params	Parameters at which to evaluate field
result	Result of evaluation
num_tuples	Size of evaluated field, in number of values

Definition at line 569 of file ElemEvaluator.hpp.

References entDim, entHandle, entType, evalSets, MBMAXTYPE, numTuples, tagCoords, tagSpace, vertPos, and workSpace.

Referenced by moab::DataCoupler::interpolate(), test_eval(), and time_forward_eval().

{
    assert( entHandle && MBMAXTYPE != entType );
    return ( *evalSets[entType].evalFcn )(
        params, ( tagCoords ? (const double*)vertPos[0].array() : (const double*)&tagSpace[0] ), entDim,
        ( -1 == num_tuples ? numTuples : num_tuples ), workSpace, result );
}

ErrorCode moab::ElemEvaluator::find_containing_entity	(	Range &	entities,
		const double *	point,
		const double	iter_tol,
		const double	inside_tol,
		EntityHandle &	containing_ent,
		double *	params,
		unsigned int *	num_evals = `NULL`
	)

Given a list of entities, return the entity the point is in, or none This function reverse-evaluates the entities, returning the first entity containing the point. If no entity contains the point, containing_ent is returned as 0 and params are unchanged. This function returns something other than MB_SUCCESS only when queries go wrong for some reason. num_evals, if non-NULL, is always incremented for each call to reverse_eval. This function calls set_ent_handle for each entity before calling reverse_eval, so the ElemEvaluator object is changed.

Parameters:

entities	Entities tested
point	Point tested, must have 3 dimensions, even for edge and face entities
iter_tol	Tolerance for non-linear reverse evaluation
inside_tol	Tolerance for is_inside test
containing_ent	Entity containing the point, returned 0 if no entity
params	Parameters of point in containing entity, unchanged if no containing entity
num_evals	If non-NULL, incremented each time reverse_eval is called

Returns:: Returns non-success only if evaulation failed for some reason (point not in element is NOT a reason for failure)

Definition at line 137 of file ElemEvaluator.cpp.

References moab::Range::begin(), moab::Range::end(), ErrorCode, MB_SUCCESS, reverse_eval(), and set_ent_handle().

Referenced by moab::BVHTree::bruteforce_find(), moab::BVHTree::distance_search(), moab::AdaptiveKDTree::distance_search(), find_containing_entity(), moab::AdaptiveKDTree::point_search(), and moab::BVHTree::point_search().

{
    int is_inside;
    ErrorCode rval      = MB_SUCCESS;
    unsigned int nevals = 0;
    Range::iterator i;
    for( i = entities.begin(); i != entities.end(); ++i )
    {
        nevals++;
        set_ent_handle( *i );
        rval = reverse_eval( point, iter_tol, inside_tol, params, &is_inside );
        if( MB_SUCCESS != rval ) return rval;
        if( is_inside ) break;
    }
    containing_ent = ( i == entities.end() ? 0 : *i );
    if( num_evals ) *num_evals += nevals;
    return MB_SUCCESS;
}

ErrorCode moab::ElemEvaluator::find_containing_entity	(	EntityHandle	ent_set,
		const double *	point,
		const double	iter_tol,
		const double	inside_tol,
		EntityHandle &	containing_ent,
		double *	params,
		unsigned int *	num_evals = `NULL`
	)		`[inline]`

Given an entity set, return the contained entity the point is in, or none This function reverse-evaluates the entities, returning the first entity containing the point. If no entity contains the point, containing_ent is returned as 0 and params are unchanged. This function returns something other than MB_SUCCESS only when queries go wrong for some reason. num_evals, if non-NULL, is always incremented for each call to reverse_eval. This function calls set_ent_handle for each entity before calling reverse_eval, so the ElemEvaluator object is changed.

Parameters:

ent_set	Entity set containing the entities to be tested
point	Point tested, must have 3 dimensions, even for edge and face entities
iter_tol	Tolerance for non-linear reverse evaluation
inside_tol	Tolerance for is_inside test
containing_ent	Entity containing the point, returned 0 if no entity
params	Parameters of point in containing entity, unchanged if no containing entity
num_evals	If non-NULL, incremented each time reverse_eval is called

Returns:: Returns non-success only if evaulation failed for some reason (point not in element is NOT a reason for failure)

Definition at line 620 of file ElemEvaluator.hpp.

References entities, ErrorCode, find_containing_entity(), moab::Interface::get_entities_by_handle(), MB_SUCCESS, MBENTITYSET, mbImpl, and moab::Interface::type_from_handle().

{
    assert( mbImpl->type_from_handle( ent_set ) == MBENTITYSET );
    Range entities;
    ErrorCode rval = mbImpl->get_entities_by_handle( ent_set, entities );
    if( MB_SUCCESS != rval )
        return rval;
    else
        return find_containing_entity( entities, point, iter_tol, inside_tol, containing_ent, params, num_evals );
}

EntityHandle moab::ElemEvaluator::get_ent_handle ( ) const [inline]

Get entity handle for this ElemEval.

Definition at line 307 of file ElemEvaluator.hpp.

References entHandle.

Referenced by test_eval().

    {
        return entHandle;
    }

EvalSet moab::ElemEvaluator::get_eval_set ( EntityType tp ) [inline]

Get the eval set for a given type entity.

Definition at line 298 of file ElemEvaluator.hpp.

References evalSets.

Referenced by set_ent_handle(), and set_eval_set().

    {
        return evalSets[tp];
    }

Interface* moab::ElemEvaluator::get_moab ( ) [inline]

Definition at line 372 of file ElemEvaluator.hpp.

References mbImpl.

Referenced by test_eval().

    {
        return mbImpl;
    }

ErrorCode moab::ElemEvaluator::get_normal	(	const int	ientDim,
		const int	facet,
		double	normal[3]
	)		const `[inline]`

Evaluate the normal to a facet of an entity.

Evaluate the normal of the cached entity at a given facet.

Parameters:

ientDim	Dimension of the facet. Should be (d-1) for d-dimensional entities
facet	Local id of the facet w.r.t the entity
normal	Returns the normal.

Definition at line 590 of file ElemEvaluator.hpp.

References moab::CartVect::array(), entHandle, entType, evalSets, MBMAXTYPE, numVerts, and vertPos.

Referenced by test_normal_linear_hex(), test_normal_linear_quad(), test_normal_linear_tet(), and test_normal_linear_tri().

{
    assert( entHandle && MBMAXTYPE != entType );
    return ( *evalSets[entType].normalFcn )( ientDim, facet, numVerts, vertPos[0].array(), normal );
}

int moab::ElemEvaluator::get_num_verts ( ) const [inline]

Definition at line 326 of file ElemEvaluator.hpp.

References numVerts.

Referenced by test_eval().

    {
        return numVerts;
    }

Tag moab::ElemEvaluator::get_tag_handle ( ) const [inline]

Definition at line 332 of file ElemEvaluator.hpp.

References tagHandle.

    {
        return tagHandle;
    };

int moab::ElemEvaluator::get_tagged_ent_dim ( ) const [inline]

Definition at line 354 of file ElemEvaluator.hpp.

References taggedEntDim.

    {
        return taggedEntDim;
    };

const EntityHandle* moab::ElemEvaluator::get_vert_handles ( ) const [inline]

Definition at line 320 of file ElemEvaluator.hpp.

References vertHandles.

Referenced by test_eval().

    {
        return vertHandles;
    }

double* moab::ElemEvaluator::get_vert_pos ( ) [inline]

Definition at line 314 of file ElemEvaluator.hpp.

References moab::CartVect::array(), and vertPos.

Referenced by test_eval().

    {
        return vertPos[0].array();
    }

double* moab::ElemEvaluator::get_work_space ( ) [inline]

Definition at line 366 of file ElemEvaluator.hpp.

References workSpace.

Referenced by test_eval().

    {
        return workSpace;
    }

int moab::ElemEvaluator::inside	(	const double *	params,
		const double	tol
	)		const `[inline]`

Return whether a physical position is inside the cached entity to within a tolerance.

Parameters:

params	Parameters at which to query the element
tol	Tolerance, usually 10^-6 or so

Definition at line 637 of file ElemEvaluator.hpp.

References entDim, entType, and evalSets.

Referenced by test_eval().

{
    return ( *evalSets[entType].insideFcn )( params, entDim, tol );
}

ErrorCode moab::ElemEvaluator::integrate ( double * result ) const [inline]

Integrate the cached tag over the cached entity.

Parameters:

result Result of the integration

Definition at line 604 of file ElemEvaluator.hpp.

References moab::CartVect::array(), entDim, entHandle, entType, ErrorCode, evalSets, MB_SUCCESS, mbImpl, MBMAXTYPE, numTuples, numVerts, moab::Interface::tag_get_data(), tagCoords, taggedEntDim, tagHandle, tagSpace, vertHandles, vertPos, and workSpace.

Referenced by test_eval(), test_evals(), and time_integrate().

{
    assert( entHandle && MBMAXTYPE != entType && ( tagCoords || tagHandle ) );
    ErrorCode rval = MB_SUCCESS;
    if( !tagCoords )
    {
        if( 0 == taggedEntDim )
            rval = mbImpl->tag_get_data( tagHandle, vertHandles, numVerts, (void*)&tagSpace[0] );
        else
            rval = mbImpl->tag_get_data( tagHandle, &entHandle, 1, (void*)&tagSpace[0] );
        if( MB_SUCCESS != rval ) return rval;
    }
    return ( *evalSets[entType].integrateFcn )( ( tagCoords ? vertPos[0].array() : (const double*)&tagSpace[0] ),
                                                vertPos[0].array(), numVerts, entDim, numTuples, workSpace, result );
}

ErrorCode moab::ElemEvaluator::jacobian	(	const double *	params,
		double *	result
	)		const `[inline]`

Evaluate the jacobian of the cached entity at a given parametric location.

Parameters:

params	Parameters at which to evaluate jacobian
result	Result of evaluation, in the form of a 3x3 matrix, stored in column-major order

Definition at line 597 of file ElemEvaluator.hpp.

References moab::CartVect::array(), entDim, entHandle, entType, evalSets, MBMAXTYPE, numVerts, vertPos, and workSpace.

Referenced by test_eval(), and time_jacobian().

{
    assert( entHandle && MBMAXTYPE != entType );
    return ( *evalSets[entType].jacobianFcn )( params, vertPos[0].array(), numVerts, entDim, workSpace, result );
}

ErrorCode moab::ElemEvaluator::reverse_eval	(	const double *	posn,
		double	iter_tol,
		double	inside_tol,
		double *	params,
		int *	is_inside = `NULL`
	)		const `[inline]`

Reverse-evaluate the cached entity at a given physical position.

Parameters:

posn	Position at which to evaluate parameters
iter_tol	Tolerance of reverse evaluation non-linear iteration, usually 10^-10 or so
inside_tol	Tolerance of is_inside evaluation, usually 10^-6 or so
params	Result of evaluation
is_inside	If non-NULL, returns true of resulting parameters place the point inside the element (in most cases, within [-1]*(dim)

Definition at line 577 of file ElemEvaluator.hpp.

References moab::CartVect::array(), entDim, entHandle, entType, moab::EvalSet::evalFcn, evalSets, moab::EvalSet::insideFcn, moab::EvalSet::jacobianFcn, MBMAXTYPE, numVerts, vertPos, and workSpace.

Referenced by find_containing_entity(), moab::BVHTree::find_point(), test_eval(), and time_reverse_eval().

{
    assert( entHandle && MBMAXTYPE != entType );
    return ( *evalSets[entType].reverseEvalFcn )( evalSets[entType].evalFcn, evalSets[entType].jacobianFcn,
                                                  evalSets[entType].insideFcn, posn, vertPos[0].array(), numVerts,
                                                  entDim, iter_tol, inside_tol, workSpace, params, ins );
}

ErrorCode moab::ElemEvaluator::set_ent_handle ( EntityHandle ent ) [inline]

Set entity handle & cache connectivty & vertex positions.

Definition at line 435 of file ElemEvaluator.hpp.

References moab::CartVect::array(), moab::Interface::dimension_from_handle(), entDim, entHandle, entType, ErrorCode, evalSets, moab::Interface::get_connectivity(), moab::Interface::get_coords(), get_eval_set(), MB_SUCCESS, mbImpl, numVerts, set_tag_handle(), tagHandle, moab::Interface::type_from_handle(), vertHandles, vertPos, and workSpace.

Referenced by ElemEvaluator(), find_containing_entity(), moab::BVHTree::find_point(), moab::DataCoupler::interpolate(), test_evals(), test_normal_linear_hex(), test_normal_linear_quad(), test_normal_linear_tet(), test_normal_linear_tri(), time_forward_eval(), time_integrate(), time_jacobian(), and time_reverse_eval().

{
    entHandle = ent;
    if( workSpace )
    {
        delete[] workSpace;
        workSpace = NULL;
    }

    entType = mbImpl->type_from_handle( ent );
    entDim  = mbImpl->dimension_from_handle( ent );

    std::vector< EntityHandle > dum_vec;
    ErrorCode rval = mbImpl->get_connectivity( ent, vertHandles, numVerts, false, &dum_vec );
    if( MB_SUCCESS != rval ) return rval;

    if( !evalSets[entType].evalFcn ) EvalSet::get_eval_set( entType, numVerts, evalSets[entType] );

    rval = mbImpl->get_coords( vertHandles, numVerts, vertPos[0].array() );
    if( MB_SUCCESS != rval ) return rval;

    if( tagHandle )
    {
        rval = set_tag_handle( tagHandle );
        if( MB_SUCCESS != rval ) return rval;
    }
    if( evalSets[entType].initFcn ) return ( *evalSets[entType].initFcn )( vertPos[0].array(), numVerts, workSpace );
    return MB_SUCCESS;
}

ErrorCode moab::ElemEvaluator::set_eval_set	(	EntityType	tp,
		const EvalSet &	eval_set
	)		`[inline]`

Set the eval set for a given type entity.

Parameters:

tp	Entity type for which to set the eval set
eval_set	Eval set object to use

Definition at line 558 of file ElemEvaluator.hpp.

References entHandle, entType, ErrorCode, evalSets, moab::EvalSet::initFcn, MB_SUCCESS, numVerts, vertPos, and workSpace.

Referenced by moab::DataCoupler::DataCoupler(), main(), test_linear_hex(), test_linear_quad(), test_linear_tet(), test_normal_linear_hex(), test_normal_linear_quad(), test_normal_linear_tet(), test_normal_linear_tri(), test_quadratic_hex(), time_forward_eval(), time_integrate(), time_jacobian(), and time_reverse_eval().

{
    evalSets[tp] = eval_set;
    if( entHandle && evalSets[entType].initFcn )
    {
        ErrorCode rval = ( *evalSets[entType].initFcn )( vertPos[0].array(), numVerts, workSpace );
        if( MB_SUCCESS != rval ) return rval;
    }
    return MB_SUCCESS;
}

ErrorCode moab::ElemEvaluator::set_eval_set ( const EntityHandle eh ) [inline]

Set the eval set using a given entity handle This function queries the entity type and number of vertices on the entity to decide which type of shape function to use. NOTE: this function should only be called after setting a valid MOAB instance on the evaluator.

Parameters:

eh	Entity handle whose type and #vertices are queried

Definition at line 642 of file ElemEvaluator.hpp.

References ErrorCode, evalSets, get_eval_set(), mbImpl, and moab::Interface::type_from_handle().

{
    EvalSet eset;
    ErrorCode rval = EvalSet::get_eval_set( mbImpl, eh, evalSets[mbImpl->type_from_handle( eh )] );
    return rval;
}

ErrorCode moab::ElemEvaluator::set_tag	(	const char *	tag_name,
		int	tagged_ent_dim = `-1`
	)		`[inline]`

Definition at line 507 of file ElemEvaluator.hpp.

References entDim, entHandle, ErrorCode, moab::CN::MAX_NODES_PER_ELEMENT, MB_SUCCESS, mbImpl, numTuples, numVerts, moab::Interface::tag_get_bytes(), moab::Interface::tag_get_data(), moab::Interface::tag_get_handle(), moab::Interface::tag_get_length(), tagCoords, taggedEntDim, tagHandle, tagSpace, and vertHandles.

{
    ErrorCode rval = MB_SUCCESS;
    if( !tag_name || strlen( tag_name ) == 0 ) return MB_FAILURE;
    Tag tag;
    if( !strcmp( tag_name, "COORDS" ) )
    {
        tagCoords    = true;
        taggedEntDim = 0;
        numTuples    = 3;
        tagHandle    = 0;
        // can return here, because vertex coords already cached when entity handle set
        return rval;
    }
    else
    {
        rval = mbImpl->tag_get_handle( tag_name, tag );
        if( MB_SUCCESS != rval ) return rval;

        if( tagHandle != tag )
        {
            tagHandle = tag;
            rval      = mbImpl->tag_get_length( tagHandle, numTuples );
            if( MB_SUCCESS != rval ) return rval;
            int sz;
            rval = mbImpl->tag_get_bytes( tag, sz );
            if( MB_SUCCESS != rval ) return rval;
            tagSpace.reserve( CN::MAX_NODES_PER_ELEMENT * sz );
            tagCoords = false;
        }

        taggedEntDim = ( -1 == tagged_ent_dim ? entDim : tagged_ent_dim );
    }

    if( entHandle )
    {
        if( 0 == taggedEntDim )
        {
            rval = mbImpl->tag_get_data( tagHandle, vertHandles, numVerts, &tagSpace[0] );
            if( MB_SUCCESS != rval ) return rval;
        }
        else if( taggedEntDim == entDim )
        {
            rval = mbImpl->tag_get_data( tagHandle, &entHandle, 1, &tagSpace[0] );
            if( MB_SUCCESS != rval ) return rval;
        }
    }

    return rval;
}

ErrorCode moab::ElemEvaluator::set_tag_handle	(	Tag	tag,
		int	tagged_ent_dim = `-1`
	)		`[inline]`

Definition at line 465 of file ElemEvaluator.hpp.

References entDim, entHandle, ErrorCode, moab::CN::MAX_NODES_PER_ELEMENT, MB_SUCCESS, mbImpl, numTuples, numVerts, moab::Interface::tag_get_bytes(), moab::Interface::tag_get_data(), moab::Interface::tag_get_length(), tagCoords, taggedEntDim, tagHandle, tagSpace, and vertHandles.

Referenced by ElemEvaluator(), moab::DataCoupler::interpolate(), set_ent_handle(), test_eval(), test_evals(), test_linear_hex(), test_linear_quad(), test_linear_tet(), test_quadratic_hex(), time_forward_eval(), time_integrate(), time_jacobian(), and time_reverse_eval().

{
    ErrorCode rval = MB_SUCCESS;
    if( !tag && !tagged_ent_dim )
    {
        tagCoords    = true;
        numTuples    = 3;
        taggedEntDim = 0;
        tagHandle    = 0;
        return rval;
    }
    else if( tagHandle != tag )
    {
        tagHandle = tag;
        rval      = mbImpl->tag_get_length( tagHandle, numTuples );
        if( MB_SUCCESS != rval ) return rval;
        int sz;
        rval = mbImpl->tag_get_bytes( tag, sz );
        if( MB_SUCCESS != rval ) return rval;
        tagSpace.resize( CN::MAX_NODES_PER_ELEMENT * sz );
        tagCoords = false;
    }

    taggedEntDim = ( -1 == tagged_ent_dim ? 0 : tagged_ent_dim );

    if( entHandle )
    {
        if( 0 == taggedEntDim )
        {
            rval = mbImpl->tag_get_data( tagHandle, vertHandles, numVerts, &tagSpace[0] );
            if( MB_SUCCESS != rval ) return rval;
        }
        else if( taggedEntDim == entDim )
        {
            rval = mbImpl->tag_get_data( tagHandle, &entHandle, 1, &tagSpace[0] );
            if( MB_SUCCESS != rval ) return rval;
        }
    }

    return rval;
}