Utility to set slaved vs. non-slaved vertices. More...

#include <SlaveBoundaryVertices.hpp>

Inheritance diagram for MBMesquite::SlaveBoundaryVertices:

Collaboration diagram for MBMesquite::SlaveBoundaryVertices:

Public Member Functions
	SlaveBoundaryVertices (unsigned depth, unsigned max_boundary_domain_dimension=4)
	Define defintion of boundary as either the distance from a fixed vertex or the distance from the domain of the boundary vertices.
virtual double	loop_over_mesh (MeshDomainAssoc mesh_and_domain, const Settings settings, MsqError &err)
virtual std::string	get_name () const
	Get string name for use in diagnostic and status output.
virtual void	initialize_queue (MeshDomainAssoc mesh_and_domain, const Settings settings, MsqError &err)
unsigned	get_num_boundary_layers () const
bool	boundary_is_fixed_vertices () const
bool	boundary_is_mesh_domain () const
unsigned	boundary_mesh_domain_dimension () const
Private Attributes
unsigned	elemDepth
unsigned	domainDoF

Detailed Description

Utility to set slaved vs. non-slaved vertices.

This class can be inserted in the instruction queue before any optimization to determine which higher-order nodes are slaved as a function of their distance from the bounary of the mesh.

This implementation assumes that the boundary of the mesh can be identified either by dimension of the associated geometric domain or by fixed vertices.

Definition at line 51 of file SlaveBoundaryVertices.hpp.

Constructor & Destructor Documentation

MBMesquite::SlaveBoundaryVertices::SlaveBoundaryVertices	(	unsigned	depth,
		unsigned	max_boundary_domain_dimension = `4`
	)

Define defintion of boundary as either the distance from a fixed vertex or the distance from the domain of the boundary vertices.

If the second parameter is not specified, the boundary will be assumed to be indicated by fixed vertices. If it is specified, the boundary will be assumed to be those vertices constrained to a domain less than or equal to the specified dimension (I.e. vertices constrained such that the number of degrees of freedom in their motion is less than or equal to the specified number.)

Parameters:

depth	The number of elements inwards from the boundary for which all contained higher-order nodes will be free variables in the optimization. Any vertex for further from the boundary will be slaved. Specifying zero will result in all higher-order nodes being slaved except free nodes on the boundary.
max_boundary_domain_dimension	Specify the definition of "boundary". If greater than or equal to 4, then the the set of all fixed vertices is assumed to be the boundary. If less than four, then all vertices constrained to a domain with the specified number of fewer degrees of freedom (constrained to a geometric entity with an equal or smaller topological dimension) will be considered to be the boundary.

Definition at line 44 of file SlaveBoundaryVertices.cpp.

: elemDepth( depth ), domainDoF( dim ) {}

Member Function Documentation

bool MBMesquite::SlaveBoundaryVertices::boundary_is_fixed_vertices ( ) const [inline]

Definition at line 92 of file SlaveBoundaryVertices.hpp.

    {
        return domainDoF >= 4;
    }

bool MBMesquite::SlaveBoundaryVertices::boundary_is_mesh_domain ( ) const [inline]

Definition at line 96 of file SlaveBoundaryVertices.hpp.

    {
        return domainDoF < 4;
    }

unsigned MBMesquite::SlaveBoundaryVertices::boundary_mesh_domain_dimension ( ) const [inline]

Definition at line 100 of file SlaveBoundaryVertices.hpp.

    {
        return domainDoF;
    }

std::string MBMesquite::SlaveBoundaryVertices::get_name ( ) const [virtual]

Get string name for use in diagnostic and status output.

Implements MBMesquite::Instruction.

Definition at line 46 of file SlaveBoundaryVertices.cpp.

{
    return "SlaveBoundaryVertices";
}

unsigned MBMesquite::SlaveBoundaryVertices::get_num_boundary_layers ( ) const [inline]

Definition at line 88 of file SlaveBoundaryVertices.hpp.

    {
        return elemDepth;
    }

void MBMesquite::SlaveBoundaryVertices::initialize_queue	(	MeshDomainAssoc *	mesh_and_domain,
		const Settings *	settings,
		MsqError &	err
	)		`[virtual]`

Called for all instructions in queue before loop_over_mesh is called for any insetruction in queue. Default behavior is to do nothing.

Implements MBMesquite::Instruction.

Definition at line 196 of file SlaveBoundaryVertices.cpp.

{}

double MBMesquite::SlaveBoundaryVertices::loop_over_mesh	(	MeshDomainAssoc *	mesh_and_domain,
		const Settings *	settings,
		MsqError &	err
	)		`[virtual]`

Virtual fuction implementing primary functionaliy of instruction instance.

Implements MBMesquite::Instruction.

Definition at line 51 of file SlaveBoundaryVertices.cpp.

References MBMesquite::arrptr(), conn, corners, dim, dof(), MBMesquite::MeshDomain::domain_DoF(), domainDoF, elemDepth, MBMesquite::Mesh::elements_get_attached_vertices(), MBMesquite::Mesh::elements_get_topologies(), fixed, MBMesquite::Settings::FIXED_FLAG, MBMesquite::Mesh::get_all_elements(), MBMesquite::Mesh::get_all_vertices(), MBMesquite::MeshDomainAssoc::get_domain(), MBMesquite::Settings::get_fixed_vertex_mode(), MBMesquite::MeshDomainAssoc::get_mesh(), MBMesquite::Settings::get_slaved_ho_node_mode(), MBMesquite::MsqError::INVALID_MESH, MBMesquite::MsqError::INVALID_STATE, mesh, MBMesquite::MsqVertex::MSQ_DEPENDENT, MSQ_ERRZERO, MSQ_SETERR, MBMesquite::Settings::SLAVE_CALCULATED, MBMesquite::Mesh::vertices_get_byte(), MBMesquite::Mesh::vertices_get_fixed_flag(), and MBMesquite::Mesh::vertices_set_byte().

Referenced by SlaveBoundaryVerticesTest::test_fail_if_slaves_not_calculated(), and SlaveBoundaryVerticesTest::test_slaved_common().

{
    Mesh* mesh         = mesh_and_domain->get_mesh();
    MeshDomain* domain = mesh_and_domain->get_domain();

    if( settings->get_slaved_ho_node_mode() != Settings::SLAVE_CALCULATED )
    {
        MSQ_SETERR( err )
        ( "Request to calculate higher-order node slaved status "
          "when Settings::get_get_slaved_ho_node_mode() "
          "!= SLAVE_CALCUALTED",
          MsqError::INVALID_STATE );
        return 0.0;
    }

    // If user said that we should treat fixed vertices as the
    // boundary, but specified that fixed vertices are defined
    // by the dimension of their geometric domain, then just
    // do distance from the geometric domain.
    int dim = this->domainDoF;
    if( dim >= 4 && settings->get_fixed_vertex_mode() != Settings::FIXED_FLAG ) dim = settings->get_fixed_vertex_mode();

    // Create a map to contain vertex depth.  Intiliaze all to
    // elemDepth+1.
    std::vector< Mesh::VertexHandle > vertices;
    mesh->get_all_vertices( vertices, err );
    MSQ_ERRZERO( err );
    if( vertices.empty() ) return 0.0;
    std::sort( vertices.begin(), vertices.end() );
    std::vector< unsigned short > depth( vertices.size(), elemDepth + 1 );
    std::vector< bool > fixed;
    mesh->vertices_get_fixed_flag( arrptr( vertices ), fixed, vertices.size(), err );
    MSQ_ERRZERO( err );

    // Initialize map with boundary vertices.
    if( dim >= 4 )
    {
        for( size_t i = 0; i < vertices.size(); ++i )
            if( fixed[i] ) depth[i] = 0;
    }
    else
    {
        if( !domain )
        {
            MSQ_SETERR( err )
            ( "Request to calculate higher-order node slaved status "
              "by distance from bounding domain without a domain.",
              MsqError::INVALID_STATE );
            return 0.0;
        }

        std::vector< unsigned short > dof( vertices.size() );
        domain->domain_DoF( arrptr( vertices ), arrptr( dof ), vertices.size(), err );
        MSQ_ERRZERO( err );
        for( size_t i = 0; i < vertices.size(); ++i )
            if( dof[i] <= dim ) depth[i] = 0;
    }

    // Now iterate over elements repeatedly until we've found all of the
    // elements near the boundary.  This could be done much more efficiently
    // using vertex-to-element adjacencies, but it is to common for
    // applications not to implement that unless doing relaxation smoothing.
    // This is O(elemDepth * elements.size() * ln(vertices.size()));
    std::vector< Mesh::ElementHandle > elements;
    std::vector< Mesh::ElementHandle >::const_iterator j, k;
    std::vector< Mesh::VertexHandle > conn;
    std::vector< size_t > junk( 2 );
    mesh->get_all_elements( elements, err );
    MSQ_ERRZERO( err );
    if( elements.empty() ) return 0.0;
    bool some_changed;
    do
    {
        some_changed = false;
        for( j = elements.begin(); j != elements.end(); ++j )
        {
            conn.clear();
            junk.clear();
            mesh->elements_get_attached_vertices( &*j, 1, conn, junk, err );
            MSQ_ERRZERO( err );
            unsigned short elem_depth = elemDepth + 1;
            for( k = conn.begin(); k != conn.end(); ++k )
            {
                size_t i = std::lower_bound( vertices.begin(), vertices.end(), *k ) - vertices.begin();
                if( i == vertices.size() )
                {
                    MSQ_SETERR( err )
                    ( "Invalid vertex handle in element connectivity list.", MsqError::INVALID_MESH );
                    return 0.0;
                }
                if( depth[i] < elem_depth ) elem_depth = depth[i];
            }
            if( elem_depth == elemDepth + 1 ) continue;

            ++elem_depth;
            for( k = conn.begin(); k != conn.end(); ++k )
            {
                size_t i = std::lower_bound( vertices.begin(), vertices.end(), *k ) - vertices.begin();
                if( depth[i] > elem_depth )
                {
                    depth[i]     = elem_depth;
                    some_changed = true;
                }
            }
        }  // for(elements)
    } while( some_changed );

    // Now remove any corner vertices from the slaved set
    std::vector< Mesh::VertexHandle >::iterator p;
    std::vector< EntityTopology > types( elements.size() );
    mesh->elements_get_topologies( arrptr( elements ), arrptr( types ), elements.size(), err );
    MSQ_ERRZERO( err );
    for( j = elements.begin(); j != elements.end(); ++j )
    {
        const unsigned corners = TopologyInfo::corners( types[j - elements.begin()] );
        conn.clear();
        junk.clear();
        mesh->elements_get_attached_vertices( &*j, 1, conn, junk, err );
        MSQ_ERRZERO( err );
        for( unsigned i = 0; i < corners; ++i )
        {
            p                           = std::lower_bound( vertices.begin(), vertices.end(), conn[i] );
            depth[p - vertices.begin()] = 0;
        }
    }

    // Now mark all vertices *not* within specified depth as slave vertices.
    std::vector< unsigned char > bytes( vertices.size() );
    mesh->vertices_get_byte( arrptr( vertices ), arrptr( bytes ), vertices.size(), err );
    MSQ_ERRZERO( err );
    for( size_t i = 0; i < vertices.size(); ++i )
    {
        if( depth[i] <= elemDepth || fixed[i] )
            bytes[i] &= ~MsqVertex::MSQ_DEPENDENT;
        else
            bytes[i] |= MsqVertex::MSQ_DEPENDENT;
    }

    mesh->vertices_set_byte( arrptr( vertices ), arrptr( bytes ), vertices.size(), err );
    MSQ_ERRZERO( err );
    return 0.0;
}

Member Data Documentation

unsigned MBMesquite::SlaveBoundaryVertices::domainDoF [private]

Definition at line 107 of file SlaveBoundaryVertices.hpp.

Referenced by loop_over_mesh().

unsigned MBMesquite::SlaveBoundaryVertices::elemDepth [private]

Definition at line 106 of file SlaveBoundaryVertices.hpp.

Referenced by loop_over_mesh().

List of all members.

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

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation