Class with convenience functions for handling spectral mesh Class with convenience functions for handling spectral meshes. See description of spectral mesh handling in doc/metadata_info.doc and in the MOAB user's guide. More...

#include <SpectralMeshTool.hpp>

Collaboration diagram for moab::SpectralMeshTool:

Public Member Functions
	SpectralMeshTool (Interface *impl, int order=0)
	Constructor.
	~SpectralMeshTool ()
	Destructor.
Tag	spectral_vertices_tag (const bool create_if_missing=false)
	Return tag used to store lexicographically-ordered vertex array NOTE: If creating this tag with this call, this SpectralMeshTool instance must already have a non-zero spectral order value set on it; the size of the spectral vertices tag depends on this order.
Tag	spectral_order_tag (const bool create_if_missing=false)
	Return tag used to store spectral order.
ErrorCode	convert_to_fine (EntityHandle spectral_set)
	Convert representation from coarse to fine Each element in set, or in interface if set is not input, is converted to fine elements, using vertices in SPECTRAL_VERTICES tagged array.
ErrorCode	convert_to_coarse (int order=0, EntityHandle spectral_set=0)
	Convert representation from fine to coarse Each element in set, or in interface if set is not input, is converted to coarse elements, with fine vertices put into SPECTRAL_VERTICES tagged array. NOTE: This function assumes that each order^d (fine) elements comprise each coarse element, and are in order of fine elements in each coarse element. If order is input as 0, looks for a SPECTRAL_ORDER tag on the mesh.
template<class T >
ErrorCode	create_spectral_elems (const T conn, int num_fine_elems, int dim, Range &output_range, int start_idx=0, Range local_gids=NULL)
	Create coarse spectral elements from fine elements pointed to by conn This function creates the coarse elements by taking conn (assumed to be in FE ordering) and picking out the corner vertices to make coarse connectivity, and the other vertices (along with corners) to make SPECTRAL_VERTICES array pointed to by each entity.
void	spectral_order (int order)
	Set spectral order for this instance.
int	spectral_order ()
	Get spectral order for this instance.
Static Public Attributes
static const short int	permute_array [] = { 0, 1, 13, 25, 3, 2, 14, 26, 7, 6, 18, 30, 11, 10, 22, 34 }
static const short int	lin_permute_array [] = { 0, 25, 34, 11 }
Private Attributes
Interface *	mbImpl
	the MB instance that this works with
Error *	mError
	error object for this tool
Tag	svTag
	SPECTRAL_VERTICES tag.
Tag	soTag
	SPECTRAL_ORDER tag.
int	spectralOrder
	order of the spectral mesh being accessed
int	spectralOrderp1
	order of the spectral mesh being accessed plus one

Detailed Description

Class with convenience functions for handling spectral mesh Class with convenience functions for handling spectral meshes. See description of spectral mesh handling in doc/metadata_info.doc and in the MOAB user's guide.

There are two primary representations of spectral meshes: a) coarse elements: with SPECTRAL_VERTICES lexicographically-ordered array of fine vertices on each element, and tags on vertices or on elements (with _LEX suffix) b) fine elements: as linear elements made from fine vertices, with tags on vertices

Definition at line 22 of file SpectralMeshTool.hpp.

Constructor & Destructor Documentation

moab::SpectralMeshTool::SpectralMeshTool	(	Interface *	impl,
		int	order = `0`
	)		`[inline]`

Constructor.

Parameters:

impl	MOAB Interface instance
order	Spectral order, defaults to 0

Definition at line 131 of file SpectralMeshTool.hpp.

References mError, and moab::Interface::query_interface().

    : mbImpl( impl ), svTag( 0 ), soTag( 0 ), spectralOrder( order ), spectralOrderp1( order + 1 )
{
    impl->query_interface( mError );
}

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

Destructor.

Definition at line 137 of file SpectralMeshTool.hpp.

{}

Member Function Documentation

ErrorCode moab::SpectralMeshTool::convert_to_coarse	(	int	order = `0`,
		EntityHandle	spectral_set = `0`
	)

Convert representation from fine to coarse Each element in set, or in interface if set is not input, is converted to coarse elements, with fine vertices put into SPECTRAL_VERTICES tagged array. NOTE: This function assumes that each order^d (fine) elements comprise each coarse element, and are in order of fine elements in each coarse element. If order is input as 0, looks for a SPECTRAL_ORDER tag on the mesh.

Parameters:

order	Order of the spectral mesh
spectral_set	Set containing spectral elements

Definition at line 72 of file SpectralMeshTool.cpp.

References moab::Range::begin(), moab::Interface::connect_iterate(), create_spectral_elems(), moab::CN::Dimension(), moab::Range::empty(), moab::Range::end(), ErrorCode, moab::Interface::get_entities_by_handle(), MB_SET_ERR, MB_SUCCESS, mbImpl, moab::Range::psize(), moab::Range::size(), spectralOrder, moab::Range::subset_by_dimension(), and moab::TYPE_FROM_HANDLE().

{
    if( order ) spectralOrder = order;
    if( !spectralOrder )
    {
        MB_SET_ERR( MB_FAILURE, "Spectral order must be set or input before converting to spectral mesh" );
    }

    Range tmp_ents, ents;
    ErrorCode rval = mbImpl->get_entities_by_handle( spectral_set, tmp_ents );
    if( MB_SUCCESS != rval || ents.empty() ) return rval;

    // get the max-dimensional elements from it
    ents = tmp_ents.subset_by_dimension( 3 );
    if( ents.empty() ) ents = tmp_ents.subset_by_dimension( 2 );
    if( ents.empty() ) ents = tmp_ents.subset_by_dimension( 1 );
    if( ents.empty() )
    {
        MB_SET_ERR( MB_FAILURE, "Can't find any entities for conversion" );
    }

    // get a ptr to connectivity
    if( ents.psize() != 1 )
    {
        MB_SET_ERR( MB_FAILURE, "Entities must be in one chunk for conversion" );
    }
    EntityHandle* conn;
    int count, verts_per_e;
    rval = mbImpl->connect_iterate( ents.begin(), ents.end(), conn, verts_per_e, count );
    if( MB_SUCCESS != rval || count != (int)ents.size() ) return rval;

    Range tmp_range;
    return create_spectral_elems( conn, ents.size(), CN::Dimension( TYPE_FROM_HANDLE( *ents.begin() ) ), tmp_range );
}

ErrorCode moab::SpectralMeshTool::convert_to_fine ( EntityHandle spectral_set )

Convert representation from coarse to fine Each element in set, or in interface if set is not input, is converted to fine elements, using vertices in SPECTRAL_VERTICES tagged array.

Parameters:

spectral_set Set containing spectral elements

Definition at line 59 of file SpectralMeshTool.cpp.

References MB_NOT_IMPLEMENTED.

{
    return MB_NOT_IMPLEMENTED;
}

template<class T >

template ErrorCode moab::SpectralMeshTool::create_spectral_elems< EntityHandle >	(	const T *	conn,
		int	num_fine_elems,
		int	dim,
		Range &	output_range,
		int	start_idx = `0`,
		Range *	local_gids = `NULL`
	)

Create coarse spectral elements from fine elements pointed to by conn This function creates the coarse elements by taking conn (assumed to be in FE ordering) and picking out the corner vertices to make coarse connectivity, and the other vertices (along with corners) to make SPECTRAL_VERTICES array pointed to by each entity.

Parameters:

conn	Connectivity of fine (linear) elements, in FE ordering
verts_per_e	Vertices per entity
num_fine_elems	Number of fine elements represented by conn
spectral_set	Set to which coarse elements should be added, if any
start_idx	Starting index in conn (for parallel support)
local_gids	If non-null, will insert all fine vertices into this range

Definition at line 108 of file SpectralMeshTool.cpp.

References moab::Range::begin(), moab::Range::end(), ErrorCode, moab::ReadUtilIface::get_element_connect(), moab::Range::insert(), lin_permute_array, MB_CHK_SET_ERR, MB_SUCCESS, MBHEX, mbImpl, MBQUAD, permute_array, moab::Interface::query_interface(), spectral_vertices_tag(), spectralOrder, spectralOrderp1, and moab::Interface::tag_iterate().

Referenced by convert_to_coarse(), and moab::NCHelperHOMME::create_mesh().

{
    assert( spectralOrder && num_fine_elems );

    // now create num_coarse_elems
    // compute the number of local elems, accounting for coarse or fine representation
    // spectral_unit is the # fine elems per coarse elem, or spectralOrder^2
    int spectral_unit    = spectralOrder * spectralOrder;
    int num_coarse_elems = num_fine_elems / spectral_unit;

    EntityHandle* new_conn;
    EntityHandle start_elem;
    ReadUtilIface* rmi;
    ErrorCode rval = mbImpl->query_interface( rmi );
    if( MB_SUCCESS != rval ) return rval;

    int verts_per_felem = spectralOrderp1 * spectralOrderp1, verts_per_celem = std::pow( (double)2.0, dim );

    rval = rmi->get_element_connect( num_coarse_elems, verts_per_celem, ( 2 == dim ? MBQUAD : MBHEX ), 0, start_elem,
                                     new_conn );MB_CHK_SET_ERR( rval, "Failed to create elems" );

    output_range.insert( start_elem, start_elem + num_coarse_elems - 1 );

    // read connectivity into that space

    // permute_array takes a 4*order^2-long vector of integers, representing the connectivity of
    // order^2 elems (fine elems in a coarse elem), and picks out the ids of the vertices necessary
    // to get a lexicographically-ordered array of vertices in a spectral element of that order
    // assert(verts_per_felem == (sizeof(permute_array)/sizeof(unsigned int)));

    // we're assuming here that elems was empty on input
    int count;
    EntityHandle* sv_ptr = NULL;
    rval = mbImpl->tag_iterate( spectral_vertices_tag( true ), output_range.begin(), output_range.end(), count,
                                (void*&)sv_ptr );MB_CHK_SET_ERR( rval, "Failed to get SPECTRAL_VERTICES ptr" );
    assert( count == num_coarse_elems );
    int f = start_idx, fs = 0, fl = 0;
    for( int c = 0; c < num_coarse_elems; c++ )
    {
        for( int i = 0; i < verts_per_celem; i++ )
            new_conn[fl + i] = conn[f + lin_permute_array[i]];
        fl += verts_per_celem;
        for( int i = 0; i < verts_per_felem; i++ )
            sv_ptr[fs + i] = conn[f + permute_array[i]];
        f += verts_per_celem * spectral_unit;
        fs += verts_per_felem;
    }
    if( local_gids ) std::copy( sv_ptr, sv_ptr + verts_per_felem * num_coarse_elems, range_inserter( *local_gids ) );

    return MB_SUCCESS;
}

void moab::SpectralMeshTool::spectral_order ( int order ) [inline]

Set spectral order for this instance.

Parameters:

order Order set on this instance

Definition at line 88 of file SpectralMeshTool.hpp.

References spectralOrder, and spectralOrderp1.

    {
        spectralOrder   = order;
        spectralOrderp1 = order + 1;
    }

int moab::SpectralMeshTool::spectral_order ( ) [inline]

Get spectral order for this instance.

Returns:: order Order set on this instance

Definition at line 97 of file SpectralMeshTool.hpp.

References spectralOrder.

    {
        return spectralOrder;
    }

Tag moab::SpectralMeshTool::spectral_order_tag ( const bool create_if_missing = false )

Return tag used to store spectral order.

Parameters:

so_tag	Spectral order tag
create_if_missing	If true, will create this tag if it doesn't exist already
create_if_missing	If true, will create this tag if it doesn't exist already

Definition at line 40 of file SpectralMeshTool.cpp.

References moab::dum, ErrorCode, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TYPE_INTEGER, mbImpl, soTag, and moab::Interface::tag_get_handle().

{
    ErrorCode rval = MB_SUCCESS;
    if( !soTag && create_if_missing )
    {

        // create it
        int dum = 0;
        rval = mbImpl->tag_get_handle( "SPECTRAL_ORDER", 1, MB_TYPE_INTEGER, soTag, MB_TAG_DENSE | MB_TAG_CREAT, &dum );
    }

    return ( rval == MB_SUCCESS ? soTag : 0 );
}

Tag moab::SpectralMeshTool::spectral_vertices_tag ( const bool create_if_missing = false )

Return tag used to store lexicographically-ordered vertex array NOTE: If creating this tag with this call, this SpectralMeshTool instance must already have a non-zero spectral order value set on it; the size of the spectral vertices tag depends on this order.

Parameters:

sv_tag	Spectral vertices tag
create_if_missing	If true, will create this tag if it doesn't exist already

Definition at line 17 of file SpectralMeshTool.cpp.

References ErrorCode, MB_SET_ERR_RET_VAL, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TYPE_HANDLE, mbImpl, spectralOrder, spectralOrderp1, svTag, and moab::Interface::tag_get_handle().

Referenced by moab::NCHelperHOMME::create_mesh(), and create_spectral_elems().

{
    ErrorCode rval = MB_SUCCESS;
    if( !svTag && create_if_missing )
    {
        if( !spectralOrder )
        {
            // should already be a spectral order tag...
            MB_SET_ERR_RET_VAL( "Spectral order must be set before creating spectral vertices tag", 0 );
        }

        // create it
        std::vector< EntityHandle > dum_val( spectralOrderp1 * spectralOrderp1, 0 );
        rval = mbImpl->tag_get_handle( "SPECTRAL_VERTICES", spectralOrderp1 * spectralOrderp1, MB_TYPE_HANDLE, svTag,
                                       MB_TAG_DENSE | MB_TAG_CREAT, &dum_val[0] );
    }

    return ( rval == MB_SUCCESS ? svTag : 0 );
}