#include <iostream>
#include <cstdlib>
#include "Mesquite.hpp"
#include "MeshImpl.hpp"
#include "MsqError.hpp"
#include "InstructionQueue.hpp"
#include "TerminationCriterion.hpp"
#include "QualityAssessor.hpp"
#include "LPtoPTemplate.hpp"
#include "LInfTemplate.hpp"
#include "TestUtil.hpp"
#include "IdealWeightMeanRatio.hpp"
#include "IdealWeightInverseMeanRatio.hpp"
#include "UntangleBetaQualityMetric.hpp"
#include "FeasibleNewton.hpp"
#include "ConditionNumberQualityMetric.hpp"

Include dependency graph for wedge_test.cpp:

Defines
#define	TOL 1e-5
#define	CPPUNIT_ASSERT(A)
#define	CPPUNIT_ASSERT_DOUBLES_EQUAL(E, V, T)
#define	CPPUNIT_ASSERT_EQUAL(E, V)
#define	CPPUNIT_ASSERT_VECTORS_EQUAL(E, V, T)
Functions
bool	smooth_mesh (MeshImpl mesh, Mesh ref_mesh, Mesh::VertexHandle vertex_8, Mesh::VertexHandle vertex_9, Vector3D delta, QualityMetric *metric)
int	main (int argc, char *[])
Variables
const unsigned	NUM_ELEM = 6
const unsigned	NUM_VERT = 14
const unsigned	VERT_PER_ELEM = 6

Define Documentation

#define CPPUNIT_ASSERT ( A )

Value:

do                                                            \
    {                                                             \
        if( !( A ) )                                              \
        {                                                         \
            std::cout << "Assertion Failed: " << #A << std::endl; \
            std::cout << "  File: " << __FILE__ << std::endl;     \
            std::cout << "  Line: " << __LINE__ << std::endl;     \
            return 1;                                             \
        }                                                         \
    } while( false )

Definition at line 57 of file wedge_test.cpp.

Referenced by main(), and smooth_mesh().

#define CPPUNIT_ASSERT_DOUBLES_EQUAL	(	E,
		V,
		T
	)

Value:

do                                                                             \
    {                                                                              \
        if( fabs( ( E ) - ( V ) ) > ( T ) )                                        \
        {                                                                          \
            std::cout << "Assertion Failed: " << #V << " == " << #E << std::endl;  \
            std::cout << "Expected: " << ( E ) << "  Got: " << ( V ) << std::endl; \
            std::cout << "  File: " << __FILE__ << std::endl;                      \
            std::cout << "  Line: " << __LINE__ << std::endl;                      \
            return 1;                                                              \
        }                                                                          \
    } while( false )

Definition at line 69 of file wedge_test.cpp.

#define CPPUNIT_ASSERT_EQUAL	(	E,
		V
	)

Value:

do                                                                             \
    {                                                                              \
        if( ( E ) != ( V ) )                                                       \
        {                                                                          \
            std::cout << "Assertion Failed: " << #V << " == " << #E << std::endl;  \
            std::cout << "Expected: " << ( E ) << "  Got: " << ( V ) << std::endl; \
            std::cout << "  File: " << __FILE__ << std::endl;                      \
            std::cout << "  Line: " << __LINE__ << std::endl;                      \
            return 1;                                                              \
        }                                                                          \
    } while( false )

Definition at line 82 of file wedge_test.cpp.

#define CPPUNIT_ASSERT_VECTORS_EQUAL	(	E,
		V,
		T
	)

Value:

do                                                                             \
    {                                                                              \
        if( !( E ).within_tolerance_box( V, T ) )                                  \
        {                                                                          \
            std::cout << "Assertion Failed: " << #V << " == " << #E << std::endl;  \
            std::cout << "Expected: " << ( E ) << "  Got: " << ( V ) << std::endl; \
            std::cout << "  File: " << __FILE__ << std::endl;                      \
            std::cout << "  Line: " << __LINE__ << std::endl;                      \
            return 1;                                                              \
        }                                                                          \
    } while( false )

Definition at line 95 of file wedge_test.cpp.

Referenced by smooth_mesh().

#define TOL 1e-5

Definition at line 29 of file wedge_test.cpp.

Function Documentation

int main	(	int	argc,
		char *	[]
	)

Definition at line 123 of file wedge_test.cpp.

References MBMesquite::arrptr(), CPPUNIT_ASSERT, CPPUNIT_ASSERT_DOUBLES_EQUAL, CPPUNIT_ASSERT_EQUAL, MBMesquite::MeshImpl::elements_get_attached_vertices(), MBMesquite::MeshImpl::elements_get_topologies(), MBMesquite::MeshImpl::get_all_elements(), MBMesquite::Vector3D::length(), mesh, meshfile, metrics, NUM_ELEM, MBMesquite::PRISM, MBMesquite::MeshImpl::read_vtk(), MBMesquite::Vector3D::set(), smooth_mesh(), VERT_PER_ELEM, and MBMesquite::MeshImpl::vertices_get_coordinates().

{
    if( argc != 1 )
    {
        std::cerr << "Invalid arguments.\n";
        return 2;
    }

    std::string meshfile = TestDir + "unittest/mesquite/3D/vtk/prisms/untangled/6-wedge-prism.vtk";
    unsigned i;

    MBMesquite::MsqPrintError err( cout );
    IdealWeightMeanRatio m1;
    IdealWeightInverseMeanRatio m2( err );
    ConditionNumberQualityMetric m3;
    QualityMetric* metrics[] = { &m1, &m2, &m3, 0 };

    // Read Mesh
    MBMesquite::MeshImpl mesh;
    mesh.read_vtk( meshfile.c_str(), err );
    CPPUNIT_ASSERT( !err );
    MBMesquite::MeshImpl ideal_mesh;
    ideal_mesh.read_vtk( meshfile.c_str(), err );
    CPPUNIT_ASSERT( !err );

    // Check that the mesh read correctly, and contains what is
    // expected later.

    // Get mesh data
    // Expecting file to contain 6 wedge elements constructed
    // from 14 vertices.
    std::vector< Mesh::VertexHandle > vert_array;
    std::vector< Mesh::ElementHandle > elem_array;
    std::vector< size_t > conn_offsets;
    mesh.get_all_elements( elem_array, err );
    CPPUNIT_ASSERT( !err );
    CPPUNIT_ASSERT_EQUAL( elem_array.size(), NUM_ELEM );
    mesh.elements_get_attached_vertices( arrptr( elem_array ), elem_array.size(), vert_array, conn_offsets, err );
    CPPUNIT_ASSERT( !err );
    CPPUNIT_ASSERT_EQUAL( vert_array.size(), VERT_PER_ELEM * NUM_ELEM );
    CPPUNIT_ASSERT_EQUAL( conn_offsets.size(), NUM_ELEM + 1 );
    EntityTopology type_array[NUM_ELEM];
    mesh.elements_get_topologies( arrptr( elem_array ), type_array, NUM_ELEM, err );
    CPPUNIT_ASSERT( !err );

    // Verify element types and number of vertices
    for( i = 0; i < NUM_ELEM; ++i )
    {
        CPPUNIT_ASSERT_EQUAL( type_array[i], PRISM );
        CPPUNIT_ASSERT_EQUAL( conn_offsets[i], VERT_PER_ELEM * i );
    }

    // All wedges should share the 9th and 10th vertices
    const unsigned INDEX_8 = 1, INDEX_9 = 4;
    Mesh::VertexHandle handle8 = vert_array[INDEX_8];
    Mesh::VertexHandle handle9 = vert_array[INDEX_9];
    for( i = 1; i < NUM_ELEM; ++i )
    {
        CPPUNIT_ASSERT_EQUAL( vert_array[VERT_PER_ELEM * i + INDEX_8], handle8 );
        CPPUNIT_ASSERT_EQUAL( vert_array[VERT_PER_ELEM * i + INDEX_9], handle9 );
    }

    // The input file should be a hexagonal prism decomposed into
    // 6 wedges such that all wedges have one quad face on the
    // boundary and all wedges share a single edge which is the axis
    // of the prism.
    MsqVertex vertices[NUM_ELEM * VERT_PER_ELEM];
    mesh.vertices_get_coordinates( arrptr( vert_array ), vertices, NUM_ELEM * VERT_PER_ELEM, err );
    CPPUNIT_ASSERT( !err );
    for( i = 0; i < NUM_ELEM * VERT_PER_ELEM; ++i )
    {
        if( vert_array[i] == handle8 || vert_array[i] == handle9 )
        {
            CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.0, vertices[i][1], 1e-6 );
            CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.0, vertices[i][2], 1e-6 );
        }
        else
        {
            Vector3D xproj( vertices[i] );
            xproj[0] = 0;
            CPPUNIT_ASSERT_DOUBLES_EQUAL( 2.0, xproj.length(), 1e-6 );
        }
    }

    // Try smoothing w/out moving the free vertices and verify that
    // the smoother didn't move the vertex
    Vector3D delta( 0, 0, 0 );
    for( i = 0; metrics[i] != NULL; ++i )
        CPPUNIT_ASSERT( !smooth_mesh( &mesh, &ideal_mesh, handle8, handle9, delta, metrics[i] ) );

    // Now try moving the vertex and see if the smoother moves it back
    // to the origin
    delta.set( 0.1, 0.0, 0.1 );
    for( i = 0; metrics[i] != NULL; ++i )
        CPPUNIT_ASSERT( !smooth_mesh( &mesh, &ideal_mesh, handle8, handle9, delta, metrics[i] ) );

    // Now try moving the vertex further and see if the smoother moves it back
    // to the origin
    delta.set( 1.0, 0.0, 1.0 );
    for( i = 0; metrics[i] != NULL; ++i )
        CPPUNIT_ASSERT( !smooth_mesh( &mesh, &ideal_mesh, handle8, handle9, delta, metrics[i] ) );

    return 0;
}

bool smooth_mesh	(	MeshImpl *	mesh,
		Mesh *	ref_mesh,
		Mesh::VertexHandle	vertex_8,
		Mesh::VertexHandle	vertex_9,
		Vector3D	delta,
		QualityMetric *	metric
	)

Definition at line 228 of file wedge_test.cpp.

References MBMesquite::TerminationCriterion::add_absolute_vertex_movement(), MBMesquite::TerminationCriterion::add_iteration_limit(), MBMesquite::InstructionQueue::add_quality_assessor(), CPPUNIT_ASSERT, CPPUNIT_ASSERT_VECTORS_EQUAL, MBMesquite::QualityMetric::get_name(), origin, MBMesquite::IQInterface::run_instructions(), MBMesquite::QualityImprover::set_inner_termination_criterion(), MBMesquite::InstructionQueue::set_master_quality_improver(), MBMesquite::QualityImprover::set_outer_termination_criterion(), TOL, MBMesquite::PatchSetUser::use_global_patch(), MBMesquite::MeshImpl::vertex_set_coordinates(), and MBMesquite::MeshImpl::vertices_get_coordinates().

{
    MBMesquite::MsqPrintError err( cout );
    const Vector3D origin( 0, 0, 0 );

    // print a little output so we know when we died
    std::cout << "**************************************************************************" << std::endl
              << "* Smoothing..." << std::endl
              << "* Metric: " << metric->get_name() << std::endl
              << "* Offset: " << delta
              << std::endl  //<<
              //"**************************************************************************"
              << std::endl;

    // Set free vertices to specified position
    Mesh::VertexHandle handles[] = { vert1, vert2 };
    MsqVertex coordinates[2];
    mesh->vertices_get_coordinates( handles, coordinates, 2, err );
    CPPUNIT_ASSERT( !err );
    Vector3D coord1 = coordinates[0] + delta;
    Vector3D coord2 = coordinates[1] + delta;
    mesh->vertex_set_coordinates( vert1, coord1, err );
    CPPUNIT_ASSERT( !err );
    mesh->vertex_set_coordinates( vert2, coord2, err );
    CPPUNIT_ASSERT( !err );

    // Create an InstructionQueue
    InstructionQueue Q;

    // Set up objective function
    LPtoPTemplate obj_func( metric, 1, err );
    CPPUNIT_ASSERT( !err );

    // Create solver
    FeasibleNewton solver( &obj_func );
    CPPUNIT_ASSERT( !err );
    solver.use_global_patch();

    // Set stoping criteria for solver
    TerminationCriterion tc_inner;
    tc_inner.add_absolute_vertex_movement( 1e-7 );
    solver.set_inner_termination_criterion( &tc_inner );

    TerminationCriterion tc_outer;
    tc_outer.add_iteration_limit( 1 );
    solver.set_outer_termination_criterion( &tc_outer );

#ifdef DO_QUALITY_ASSESSOR
    QualityAssessor qa( metric, 10 );
    Q.add_quality_assessor( &qa, err );
    CPPUNIT_ASSERT( !err );
#endif

    // Add solver to queue
    Q.set_master_quality_improver( &solver, err );
    CPPUNIT_ASSERT( !err );

#ifdef DO_QUALITY_ASSESSOR
    Q.add_quality_assessor( &qa, err );
    CPPUNIT_ASSERT( !err );
#endif

    // And smooth...
    Q.run_instructions( mesh, err );
    CPPUNIT_ASSERT( !err );

    // Verify that vertices were moved back to origin
    MsqVertex new_coords[2];
    mesh->vertices_get_coordinates( handles, new_coords, 2, err );
    CPPUNIT_ASSERT( !err );

    // print a little output so we know when we died
    std::cout  //<<
               //"**************************************************************************"
        << std::endl
        << "* Done Smoothing:" << std::endl
        << "* Metric: " << metric->get_name() << std::endl
        << "* Position1: " << new_coords[0][0] << " " << new_coords[0][1] << " " << new_coords[0][2] << std::endl
        << "* Position2: " << new_coords[1][0] << " " << new_coords[1][1] << " " << new_coords[1][2] << std::endl
        << "**************************************************************************" << std::endl;

    CPPUNIT_ASSERT_VECTORS_EQUAL( coordinates[0], new_coords[0], TOL );
    CPPUNIT_ASSERT_VECTORS_EQUAL( coordinates[1], new_coords[1], TOL );
    return false;
}

Variable Documentation

const unsigned NUM_ELEM = 6

Definition at line 119 of file wedge_test.cpp.

const unsigned NUM_VERT = 14

Definition at line 120 of file wedge_test.cpp.

const unsigned VERT_PER_ELEM = 6

Definition at line 121 of file wedge_test.cpp.

Referenced by main().

Defines

Functions

Variables

Define Documentation

Function Documentation

Variable Documentation