void TagVertexMeshTest::test_alternate_name()
{
MsqPrintError err( std::cerr );
Vector3D new_coords(5, 5, 5);
MsqVertex get_coords;
std::vector<Mesh::VertexHandle> vertices;
realMesh->get_all_vertices( vertices, err );
ASSERT_NO_ERROR(err);
Mesh::VertexHandle vertex = vertices[0];
realMesh->vertices_get_coordinates( &vertex, &get_coords, 1, err );
ASSERT_NO_ERROR(err);
Vector3D orig_coords = get_coords;
// modify a vertex in the tag interface and save it
{
TagVertexMesh tag_mesh( err, realMesh, false, "foobar" );
ASSERT_NO_ERROR(err);
tag_mesh.vertex_set_coordinates( vertex, new_coords, err );
ASSERT_NO_ERROR(err);
}
// verify that it is modified in the new interface
{
TagVertexMesh tag_mesh( err, realMesh, false, "foobar" );
ASSERT_NO_ERROR(err);
tag_mesh.vertices_get_coordinates( &vertex, &get_coords, 1, err );
ASSERT_NO_ERROR(err);
CPPUNIT_ASSERT_VECTORS_EQUAL( new_coords, get_coords, DBL_EPSILON );
}
}
void TagVertexMeshTest::test_cleanup()
{
MsqPrintError err( std::cerr );
Vector3D new_coords(5, 5, 5);
MsqVertex get_coords;
std::vector<Mesh::VertexHandle> vertices;
realMesh->get_all_vertices( vertices, err );
ASSERT_NO_ERROR(err);
Mesh::VertexHandle vertex = vertices[0];
realMesh->vertices_get_coordinates( &vertex, &get_coords, 1, err );
ASSERT_NO_ERROR(err);
Vector3D orig_coords = get_coords;
// modify a vertex in the tag interface
{
TagVertexMesh tag_mesh( err, realMesh, true );
ASSERT_NO_ERROR(err);
tag_mesh.vertex_set_coordinates( vertex, new_coords, err );
ASSERT_NO_ERROR(err);
}
// check that values were cleaned up when previous instance was destroyed
{
TagVertexMesh tag_mesh( err, realMesh, false );
ASSERT_NO_ERROR(err);
tag_mesh.vertices_get_coordinates( &vertex, &get_coords, 1, err );
ASSERT_NO_ERROR(err);
CPPUNIT_ASSERT_VECTORS_EQUAL( orig_coords, get_coords, DBL_EPSILON );
}
}
void TagVertexMeshTest::test_reference_mesh()
{
MsqPrintError err( std::cerr );
TagVertexMesh tag_mesh( err, realMesh, true );
ASSERT_NO_ERROR(err);
std::vector<Mesh::VertexHandle> vertices;
realMesh->get_all_vertices( vertices, err );
ASSERT_NO_ERROR(err);
// copy real mesh coordinates into tag data in TagVertexMesh
InstructionQueue q;
q.add_tag_vertex_mesh( &tag_mesh, err );
ASSERT_NO_ERROR(err);
q.run_instructions( realMesh, err );
ASSERT_NO_ERROR(err);
// Check that initial position for vertex matches that of real mesh
Mesh::VertexHandle vertex = vertices[0];
MsqVertex get_coords;
Vector3D orig_coords, real_coords, tag_coords;
realMesh->vertices_get_coordinates( &vertex, &get_coords, 1, err );
ASSERT_NO_ERROR(err);
orig_coords = get_coords;
tag_mesh.vertices_get_coordinates( &vertex, &get_coords, 1, err );
ASSERT_NO_ERROR(err);
tag_coords = get_coords;
CPPUNIT_ASSERT_VECTORS_EQUAL( orig_coords, tag_coords, DBL_EPSILON );
// Check that modified vertex coords show up in real mesh but not
// tag mesh.
realMesh->vertices_get_coordinates( &vertex, &get_coords, 1, err );
ASSERT_NO_ERROR(err);
orig_coords = get_coords;
Vector3D new_coords(5,5,5);
realMesh->vertex_set_coordinates( vertex, new_coords, err );
ASSERT_NO_ERROR(err);
tag_mesh.vertices_get_coordinates( &vertex, &get_coords, 1, err );
ASSERT_NO_ERROR(err);
tag_coords = get_coords;
CPPUNIT_ASSERT_VECTORS_EQUAL( orig_coords, tag_coords, DBL_EPSILON );
// restore realMesh to initial state
realMesh->vertex_set_coordinates( vertex, orig_coords, err );
ASSERT_NO_ERROR(err);
}
void TagVertexMeshTest::test_vertex_coordinates()
{
MsqPrintError err( std::cerr );
TagVertexMesh tag_mesh( err, realMesh, true );
ASSERT_NO_ERROR(err);
std::vector<Mesh::VertexHandle> vertices;
realMesh->get_all_vertices( vertices, err );
ASSERT_NO_ERROR(err);
// Check that initial position for vertex matches that of real mesh
Mesh::VertexHandle vertex = vertices[0];
MsqVertex get_coords;
Vector3D orig_coords, real_coords, tag_coords;
realMesh->vertices_get_coordinates( &vertex, &get_coords, 1, err );
ASSERT_NO_ERROR(err);
orig_coords = get_coords;
tag_mesh.vertices_get_coordinates( &vertex, &get_coords, 1, err );
ASSERT_NO_ERROR(err);
tag_coords = get_coords;
CPPUNIT_ASSERT_VECTORS_EQUAL( orig_coords, tag_coords, DBL_EPSILON );
// Check that modified vertex coords show up in tag mesh but not
// real mesh.
Vector3D new_coords(5,5,5);
tag_mesh.vertex_set_coordinates( vertex, new_coords, err );
ASSERT_NO_ERROR(err);
tag_mesh.vertices_get_coordinates( &vertex, &get_coords, 1, err );
ASSERT_NO_ERROR(err);
tag_coords = get_coords;
CPPUNIT_ASSERT_VECTORS_EQUAL( new_coords, tag_coords, DBL_EPSILON );
realMesh->vertices_get_coordinates( &vertex, &get_coords, 1, err );
ASSERT_NO_ERROR(err);
real_coords = get_coords;
CPPUNIT_ASSERT_VECTORS_EQUAL( orig_coords, real_coords, DBL_EPSILON );
}
// Routine to create initial mesh for test.
// o Marks vertices at a greater topological depth than the specified
// value as slaved.
// o Perturbs higher-order vertices on skin towards element center
// o Marks skin vertices as fixed
int main( int argc, char* argv[] )
{
if (argc != 4)
usage(argv[0]);
char* endptr = 0;
const long n = strtol( argv[1], &endptr, 0 );
if (*endptr || n < 0)
usage(argv[0]);
// read input mesh
MeshImpl mesh;
MsqPrintError err(std::cerr);
mesh.read_vtk( argv[2], err );
if (err) return 1;
// get skin vertices
mesh.mark_skin_fixed( err, true );
if (err) return 1;
std::vector<Mesh::VertexHandle> verts;
mesh.get_all_vertices( verts, err );
if (err) return 1;
std::vector<bool> fixed;
mesh.vertices_get_fixed_flag( arrptr(verts), fixed, verts.size(), err );
if (err) return 1;
std::vector<Mesh::VertexHandle> skin;
for (size_t i = 0; i < verts.size(); ++i)
if (fixed[i])
skin.push_back( verts[i] );
// create map for vertex depth, and initialize to 0 for skin vertices
std::map<Mesh::VertexHandle,int> depth;
std::map<Mesh::VertexHandle,int>::iterator d_iter;
for (size_t i = 0; i < skin.size(); ++i)
depth[skin[i]] = 0;
// get all elements
std::vector<Mesh::ElementHandle> curr, next;
std::vector<Mesh::ElementHandle> conn;
std::vector<size_t> off;
mesh.get_all_elements( next, err );
// build sorted list of higher-order vertices
std::vector<Mesh::VertexHandle> higher_order;
for (size_t i = 0; i < next.size(); ++i) {
Mesh::ElementHandle elem = next[i];
conn.clear();
mesh.elements_get_attached_vertices( &elem, 1, conn, off, err );
if (err) return 1;
EntityTopology type;
mesh.elements_get_topologies( &elem, &type, 1, err );
std::copy( conn.begin() + TopologyInfo::corners(type), conn.end(),
std::back_inserter( higher_order ) );
}
std::sort( higher_order.begin(), higher_order.end() );
higher_order.erase( std::unique( higher_order.begin(), higher_order.end() ),
higher_order.end() );
// build depth map for all vertices
while (!next.empty()) {
curr.swap( next );
next.clear();
while (!curr.empty()) {
Mesh::ElementHandle elem = curr.back();
curr.pop_back();
conn.clear();
mesh.elements_get_attached_vertices( &elem, 1, conn, off, err );
if (err) return 1;
int min = std::numeric_limits<int>::max();
for (size_t i = 0; i < conn.size(); ++i) {
d_iter = depth.find( conn[i] );
if (d_iter != depth.end() && d_iter->second < min)
min = d_iter->second;
}
if (min == std::numeric_limits<int>::max()) {
next.push_back( elem );
continue;
}
for (size_t i = 0; i < conn.size(); ++i) {
d_iter = depth.find( conn[i] );
if (d_iter == depth.end() || d_iter->second > min+1)
depth[conn[i]] = min+1;
}
}
}
// write depth map to tag for debugging purposes
std::vector<int> depth_vals(verts.size());
for (size_t i = 0; i < verts.size(); ++i)
depth_vals[i] = depth[verts[i]];
TagHandle tag = mesh.tag_create( "depth", Mesh::INT, 1, 0, err );
if (err) return 1;
mesh.tag_set_vertex_data( tag, verts.size(), arrptr(verts), arrptr(depth_vals), err );
if (err) return 1;
// set tag specifying slaved vertices
for (size_t i = 0; i < verts.size(); ++i)
if (std::binary_search( higher_order.begin(), higher_order.end(), verts[i] ))
depth_vals[i] = depth[verts[i]] > n;
else
depth_vals[i] = 0;
tag = mesh.tag_create( "slaved", Mesh::INT, 1, 0, err );
if (err) return 1;
mesh.tag_set_vertex_data( tag, verts.size(), arrptr(verts), arrptr(depth_vals), err );
if (err) return 1;
// perturb mid-edge nodes along boundary
std::vector<MsqVertex> coords;
for (size_t i = 0; i < skin.size(); ++i) {
if (!std::binary_search( higher_order.begin(), higher_order.end(), skin[i]))
continue;
curr.clear();
mesh.vertices_get_attached_elements( &skin[i], 1, curr, off, err );
if (err) return 1;
assert(curr.size() == 1);
conn.clear();
mesh.elements_get_attached_vertices( arrptr(curr), 1, conn, off, err );
if (err) return 1;
// estimate element center
coords.resize( conn.size() );
mesh.vertices_get_coordinates( arrptr(conn), arrptr(coords), conn.size(), err );
if (err) return 1;
Vector3D mean(0.0);
for (size_t j = 0; j < coords.size(); ++j)
mean += coords[j];
mean /= coords.size();
size_t idx = std::find( conn.begin(), conn.end(), skin[i] ) - conn.begin();
assert(idx < conn.size());
Vector3D init = coords[idx];
Vector3D pos = (1 - PERTURB_FRACT) * init + PERTURB_FRACT * mean;
mesh.vertex_set_coordinates( skin[i], pos, err );
if (err) return 1;
}
mesh.write_vtk( argv[3], err );
if (err) return 1;
return 0;
}
int uwt( bool skip,
UntangleWrapper::UntangleMetric metric,
const char* input_file_base,
int expected,
bool flip_domain )
{
if (skip)
return 0;
if (!brief_output)
std::cout << std::endl << "**********************************************" << std::endl;
std::cout << "Running \"" << input_file_base << "\" for " << tostr(metric) << std::endl;
if (!brief_output)
std::cout << "**********************************************" << std::endl << std::endl;
// get mesh
MsqError err;
MeshImpl mesh;
std::string input_file( VTK_2D_DIR );
input_file += input_file_base;
mesh.read_vtk( input_file.c_str(), err );
if (err) {
std::cerr << err << std::endl;
std::cerr << "ERROR: " << input_file << " : failed to read file" << std::endl;
return 1;
}
// get domain
std::vector<Mesh::VertexHandle> verts;
mesh.get_all_vertices( verts, err );
if (err || verts.empty()) abort();
MsqVertex coords;
mesh.vertices_get_coordinates( arrptr(verts), &coords, 1, err );
if (err) abort();
Vector3D norm(0,0,flip_domain ? -1 : 1);
PlanarDomain domain( norm, coords );
// run wrapper
UntangleWrapper wrapper( metric );
wrapper.set_vertex_movement_limit_factor( 0.005 );
double constant = (metric == UntangleWrapper::BETA) ? beta : mu_sigma;
if (constant > 0)
wrapper.set_metric_constant( constant );
if (brief_output)
wrapper.quality_assessor().disable_printing_results();
MeshDomainAssoc mesh_and_domain = MeshDomainAssoc(&mesh, &domain);
wrapper.run_instructions( &mesh_and_domain, err );
if (err) {
std::cerr << err << std::endl;
std::cerr << "ERROR: optimization failed" << std::endl;
return 1;
}
// write output file
if (write_output) {
std::string result_file(tostr(metric));
result_file += "-";
result_file += input_file_base;
mesh.write_vtk( result_file.c_str(), err );
if (err) {
std::cerr << err << std::endl;
std::cerr << "ERROR: " << result_file << " : failed to write file" << std::endl;
err.clear();
}
else {
std::cerr << "Wrote file: " << result_file << std::endl;
}
}
// test number of inverted elements
int count, junk;
wrapper.quality_assessor().get_inverted_element_count( count, junk, err );
if (err) abort();
if (count < expected) {
std::cout << "WARNING: expected " << expected
<< " inverted elements but finished with only "
<< count << std::endl
<< "Test needs to be updated?" << std::endl << std::endl;
return 0;
}
else if (count == expected) {
std::cout << "Completed with " << count << " inverted elements remaining"
<< std::endl << std::endl;
return 0;
}
else {
std::cerr << "ERROR: expected " << expected
<< " inverted elements but finished with "
<< count << std::endl << std::endl;
return 1;
}
}
void VtkTest::test_read_quadratic( const char* filename )
{
const size_t NUM_ELEM = 8;
MeshImpl mesh;
MsqPrintError err(cout);
mesh.read_vtk( filename, err );
ASSERT_NO_ERROR(err);
std::vector<Mesh::ElementHandle> elems(NUM_ELEM);
mesh.get_all_elements( elems, err );
ASSERT_NO_ERROR(err);
CPPUNIT_ASSERT_EQUAL(elems.size(), NUM_ELEM );
std::vector<Mesh::VertexHandle> conn;
std::vector<size_t> offsets;
mesh.elements_get_attached_vertices( arrptr(elems), elems.size(), conn, offsets, err );
ASSERT_NO_ERROR(err);
CPPUNIT_ASSERT_EQUAL( conn.size(), (size_t)108 );
EntityTopology types[NUM_ELEM];
mesh.elements_get_topologies( arrptr(elems), types, NUM_ELEM, err );
ASSERT_NO_ERROR(err);
static const double hex_corners[] =
{ 1.0, -1.0, -1.0,
1.0, 1.0, -1.0,
-1.0, 1.0, -1.0,
-1.0, -1.0, -1.0,
1.0, -1.0, 1.0,
1.0, 1.0, 1.0,
-1.0, 1.0, 1.0,
-1.0, -1.0, 1.0 };
static const double tet_corners[] =
{ 1.0, -1.0, -1.0,
1.0, 1.0, -1.0,
-1.0, 0.0, -1.0,
0.0, 0.0, 1.0 };
static const double pyr_corners[] =
{ 1.0, -1.0, -1.0,
1.0, 1.0, -1.0,
-1.0, 1.0, -1.0,
-1.0, -1.0, -1.0,
0.0, 0.0, 1.0 };
static const double pri_corners[] =
{ -1.0, -1.0, -1.0,
1.0, 1.0, -1.0,
-1.0, 1.0, -1.0,
-1.0, -1.0, 1.0,
1.0, 1.0, 1.0,
-1.0, 1.0, 1.0 };
static const unsigned hex_edges[] =
{ 0, 1,
1, 2,
2, 3,
3, 0,
0, 4,
1, 5,
2, 6,
3, 7,
4, 5,
5, 6,
6, 7,
7, 4 };
static const unsigned tet_edges[] =
{ 0, 1,
1, 2,
2, 0,
0, 3,
1, 3,
2, 3 };
static const unsigned pri_edges[] =
{ 0, 1,
1, 2,
2, 0,
0, 3,
1, 4,
2, 5,
3, 4,
4, 5,
5, 3 };
static const unsigned pyr_edges[] =
{ 0, 1,
1, 2,
2, 3,
3, 0,
0, 4,
1, 4,
2, 4,
3, 4 };
static const unsigned hex_faces[] =
{ 4, 0, 1, 5, 4,
4, 1, 2, 6, 5,
4, 2, 3, 7, 6,
4, 3, 0, 4, 7,
4, 3, 2, 1, 0,
4, 4, 5, 6, 7
};
static const struct {
EntityTopology topology;
unsigned num_corners;
unsigned num_edges;
unsigned num_faces; // if non-zero expect mid-face nodes
unsigned num_region; // if non-zero expect mid-region node
const double* corners;
const unsigned* edges;
const unsigned* faces;
} expected_elems[NUM_ELEM] = {
{ Mesquite::HEXAHEDRON, 8, 12, 0, 0, hex_corners, hex_edges, hex_faces },
{ Mesquite::HEXAHEDRON, 8, 12, 6, 1, hex_corners, hex_edges, hex_faces },
{ Mesquite::TETRAHEDRON, 4, 6, 0, 0, tet_corners, tet_edges, 0 },
{ Mesquite::QUADRILATERAL, 4, 4, 0, 0, hex_corners, hex_edges, 0 },
{ Mesquite::QUADRILATERAL, 4, 4, 0, 1, hex_corners, hex_edges, 0 },
{ Mesquite::TRIANGLE, 3, 3, 0, 0, tet_corners, tet_edges, 0 },
{ Mesquite::PRISM, 6, 9, 0, 0, pri_corners, pri_edges, 0 },
{ Mesquite::PYRAMID, 5, 8, 0, 0, pyr_corners, pyr_edges, 0 } };
MsqVertex have;
std::vector<Mesh::VertexHandle>::iterator v_it = conn.begin();
for (unsigned i = 0; i < NUM_ELEM; ++i)
{
CPPUNIT_ASSERT_EQUAL( expected_elems[i].topology, types[i] );
size_t vtx_start = offsets[i];
size_t vtx_end = offsets[i+1];
size_t conn_len = expected_elems[i].num_corners
+ expected_elems[i].num_edges
+ expected_elems[i].num_faces
+ expected_elems[i].num_region;
CPPUNIT_ASSERT_EQUAL( conn_len, vtx_end - vtx_start );
for (unsigned c = 0; c < expected_elems[i].num_corners; ++c, ++v_it)
{
Vector3D expected(expected_elems[i].corners + 3*c);
mesh.vertices_get_coordinates( &*v_it, &have, 1, err );
ASSERT_NO_ERROR(err);
expected -= have;
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.0, expected.length(), DBL_EPSILON );
}
for (unsigned m = 0; m < expected_elems[i].num_edges; ++m, ++v_it)
{
unsigned start_idx = expected_elems[i].edges[2*m];
unsigned end_idx = expected_elems[i].edges[2*m+1];
Vector3D start( expected_elems[i].corners + 3*start_idx );
Vector3D end( expected_elems[i].corners + 3*end_idx );
Vector3D expected = 0.5 * (start + end);
mesh.vertices_get_coordinates( &*v_it, &have, 1, err );
ASSERT_NO_ERROR(err);
expected -= have;
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.0, expected.length(), DBL_EPSILON );
}
const unsigned* f_it = expected_elems[i].faces;
for (unsigned m = 0; m < expected_elems[i].num_faces; ++m, ++v_it)
{
Vector3D expected(0,0,0);
const unsigned face_size = *f_it; ++f_it;
CPPUNIT_ASSERT( face_size == 3u || face_size == 4u );
for (unsigned f = 0; f < face_size; ++f, ++f_it)
expected += Vector3D( expected_elems[i].corners + 3 * *f_it );
expected /= face_size;
mesh.vertices_get_coordinates( &*v_it, &have, 1, err );
ASSERT_NO_ERROR(err);
expected -= have;
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.0, expected.length(), DBL_EPSILON );
}
if (expected_elems[i].num_region) {
CPPUNIT_ASSERT_EQUAL( 1u, expected_elems[i].num_region );
Vector3D expected(0,0,0);
for (unsigned m = 0; m < expected_elems[i].num_corners; ++m)
expected += Vector3D( expected_elems[i].corners + 3*m );
expected /= expected_elems[i].num_corners;
mesh.vertices_get_coordinates( &*v_it, &have, 1, err );
ASSERT_NO_ERROR(err);
expected -= have;
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.0, expected.length(), DBL_EPSILON );
++v_it;
}
}
}
double run( QualityMetric* metric,
Solver solver_type,
const char* input_file,
double& seconds_out,
int& iterations_out )
{
MsqPrintError err(cerr);
IdealWeightInverseMeanRatio qa_metric;
TerminationCriterion inner, outer;
outer.add_iteration_limit( 1 );
inner.add_absolute_vertex_movement( 1e-4 );
inner.add_iteration_limit( 100 );
PMeanPTemplate of( 1.0, metric );
QualityAssessor qa( &qa_metric );
qa.add_quality_assessment( metric );
InstructionQueue q;
SteepestDescent steep(&of);
QuasiNewton quasi(&of);
ConjugateGradient conj(&of);
VertexMover* solver = 0;
switch (solver_type) {
case STEEP_DESCENT: solver = &steep; break;
case QUASI_NEWT:solver = &quasi;break;
case CONJ_GRAD: solver = &conj; break;
}
q.set_master_quality_improver( solver, err );
q.add_quality_assessor( &qa, err );
solver->set_inner_termination_criterion(&inner);
solver->set_outer_termination_criterion(&outer);
if (plot_file)
inner.write_iterations( plot_file, err );
MeshImpl mesh;
mesh.read_vtk( input_file, err );
if (err) {
cerr << "Failed to read input file: \"" << input_file << '"' << endl;
exit(1);
}
std::vector<Mesh::VertexHandle> handles;
mesh.get_all_vertices( handles, err );
if (handles.empty()) {
cerr << "no veritces in mesh" << endl;
exit(1);
}
std::vector<MsqVertex> coords(handles.size());
mesh.vertices_get_coordinates( arrptr(handles), arrptr(coords), handles.size(), err );
Vector3D min(HUGE_VAL), max(-HUGE_VAL);
for (size_t i = 0; i < coords.size(); ++i) {
for (int j = 0; j < 3; ++j) {
if (coords[i][j] < min[j])
min[j] = coords[i][j];
if (coords[i][j] > max[j])
max[j] = coords[i][j];
}
}
Vector3D size = max - min;
PlanarDomain* domain = 0;
if (size[0] < 1e-4)
domain = new PlanarDomain( PlanarDomain::YZ, min[0] );
else if (size[1] < 1e-4)
domain = new PlanarDomain( PlanarDomain::XZ, min[1] );
else if (size[2] < 1e-4)
domain = new PlanarDomain( PlanarDomain::XY, min[2] );
Timer timer;
q.run_instructions( &mesh, domain, err );
seconds_out = timer.since_birth();
if (err) {
cerr << "Optimization failed." << endl << err << endl;
abort();
}
if (vtk_file) {
MeshWriter::write_vtk( &mesh, vtk_file, err );
if (err)
cerr << vtk_file << ": failed to write file." << endl;
}
if (gpt_file) {
MeshWriter::write_gnuplot( &mesh, gpt_file, err );
if (err)
cerr << gpt_file << ": failed to write file." << endl;
}
if (eps_file) {
PlanarDomain xy(PlanarDomain::XY);
MeshWriter::Projection proj( domain ? domain : &xy );
MeshWriter::write_eps( &mesh, eps_file, proj, err );
if (err)
cerr << eps_file << ": failed to write file." << endl;
}
delete domain;
iterations_out = inner.get_iteration_count();
const QualityAssessor::Assessor* a = qa.get_results( &qa_metric );
return a->get_average();
}
void DomainClassifierTest::setUp()
{
myMesh.clear();
myDomains.clear();
domainDims.clear();
// vertex coodinates
const char vertex_data[] =
"POINTS 64 float\n"
"0 0 0 1 0 0 2 0 0 3 0 0\n"
"0 1 0 1 1 0 2 1 0 3 1 0\n"
"0 2 0 1 2 0 2 2 0 3 2 0\n"
"0 3 0 1 3 0 2 3 0 3 3 0\n"
"\n"
"0 0 1 1 0 1 2 0 1 3 0 1\n"
"0 1 1 1 1 1 2 1 1 3 1 1\n"
"0 2 1 1 2 1 2 2 1 3 2 1\n"
"0 3 1 1 3 1 2 3 1 3 3 1\n"
"\n"
"0 0 2 1 0 2 2 0 2 3 0 2\n"
"0 1 2 1 1 2 2 1 2 3 1 2\n"
"0 2 2 1 2 2 2 2 2 3 2 2\n"
"0 3 2 1 3 2 2 3 2 3 3 2\n"
"\n"
"0 0 3 1 0 3 2 0 3 3 0 3\n"
"0 1 3 1 1 3 2 1 3 3 1 3\n"
"0 2 3 1 2 3 2 2 3 3 2 3\n"
"0 3 3 1 3 3 2 3 3 3 3 3\n"
"\n";
// quad connectivity for quads on mesh skin
const int num_quads = 9*6; // nine per side
const char quad_data[] =
"4 1 0 4 5\n" // -z face (z == 0)
"4 2 1 5 6\n"
"4 3 2 6 7\n"
"4 5 4 8 9\n"
"4 6 5 9 10\n"
"4 7 6 10 11\n"
"4 9 8 12 13\n"
"4 10 9 13 14\n"
"4 11 10 14 15\n"
"\n"
"4 48 49 53 52\n" // +z face (z == 3)
"4 49 50 54 53\n"
"4 50 51 55 54\n"
"4 52 53 57 56\n"
"4 53 54 58 57\n"
"4 54 55 59 58\n"
"4 56 57 61 60\n"
"4 57 58 62 61\n"
"4 58 59 63 62\n"
"\n"
"4 0 1 17 16\n" // -y face (y == 0)
"4 1 2 18 17\n"
"4 2 3 19 18\n"
"4 16 17 33 32\n"
"4 17 18 34 33\n"
"4 18 19 35 34\n"
"4 32 33 49 48\n"
"4 33 34 50 49\n"
"4 34 35 51 50\n"
"\n"
"4 13 12 28 29\n" // +y face (y == 3)
"4 14 13 29 30\n"
"4 15 14 30 31\n"
"4 29 28 44 45\n"
"4 30 29 45 46\n"
"4 31 30 46 47\n"
"4 45 44 60 61\n"
"4 46 45 61 62\n"
"4 47 46 62 63\n"
"\n"
"4 4 0 16 20\n" // -x face (x == 0)
"4 8 4 20 24\n"
"4 12 8 24 28\n"
"4 20 16 32 36\n"
"4 24 20 36 40\n"
"4 28 24 40 44\n"
"4 36 32 48 52\n"
"4 40 36 52 56\n"
"4 44 40 56 60\n"
"\n"
"4 3 7 23 19\n" // +x face (x == 3)
"4 7 11 27 23\n"
"4 11 15 31 27\n"
"4 19 23 39 35\n"
"4 23 27 43 39\n"
"4 27 31 47 43\n"
"4 35 39 55 51\n"
"4 39 43 59 55\n"
"4 43 47 63 59\n"
"\n";
// hexahedron connectivity
const int num_hexes = 3*3*3;
const char hex_data[] =
"8 0 1 5 4 16 17 21 20\n"
"8 1 2 6 5 17 18 22 21\n"
"8 2 3 7 6 18 19 23 22\n"
"8 4 5 9 8 20 21 25 24\n"
"8 5 6 10 9 21 22 26 25\n"
"8 6 7 11 10 22 23 27 26\n"
"8 8 9 13 12 24 25 29 28\n"
"8 9 10 14 13 25 26 30 29\n"
"8 10 11 15 14 26 27 31 30\n"
"\n"
"8 16 17 21 20 32 33 37 36\n"
"8 17 18 22 21 33 34 38 37\n"
"8 18 19 23 22 34 35 39 38\n"
"8 20 21 25 24 36 37 41 40\n"
"8 21 22 26 25 37 38 42 41\n"
"8 22 23 27 26 38 39 43 42\n"
"8 24 25 29 28 40 41 45 44\n"
"8 25 26 30 29 41 42 46 45\n"
"8 26 27 31 30 42 43 47 46\n"
"\n"
"8 32 33 37 36 48 49 53 52\n"
"8 33 34 38 37 49 50 54 53\n"
"8 34 35 39 38 50 51 55 54\n"
"8 36 37 41 40 52 53 57 56\n"
"8 37 38 42 41 53 54 58 57\n"
"8 38 39 43 42 54 55 59 58\n"
"8 40 41 45 44 56 57 61 60\n"
"8 41 42 46 45 57 58 62 61\n"
"8 42 43 47 46 58 59 63 62\n"
"\n";
// a few interior quads
const int num_interior_quads = 3;
const char interior_quad_data[] =
"4 1 5 25 17\n"
"4 4 5 25 24\n"
"4 16 17 25 24\n"
"\n";
const char filename[] = "dctest.vtk";
FILE* file = fopen( filename, "w" );
fputs( "# vtk DataFile Version 2.0\n", file );
fputs( "Mesquite Mesh\n", file );
fputs( "ASCII\n", file );
fputs( "DATASET UNSTRUCTURED_GRID\n", file );
fputs( vertex_data, file );
int num_elem = num_quads + num_hexes + num_interior_quads;
int num_elem_data = 5*num_quads + 9*num_hexes * 5*num_interior_quads;
fprintf( file, "CELLS %d %d\n", num_elem, num_elem_data );
fputs( quad_data, file );
fputs( hex_data, file );
fputs( interior_quad_data, file );
fprintf( file, "CELL_TYPES %d\n", num_elem );
for (int i = 0; i < num_quads; ++i)
fputs( "9\n", file );
for (int i = 0; i < num_hexes; ++i)
fputs( "12\n", file );
for (int i = 0; i < num_interior_quads; ++i)
fputs( "9\n", file );
fclose( file );
MsqPrintError err(std::cerr);
myMesh.read_vtk( filename, err );
remove( filename );
CPPUNIT_ASSERT(!err);
std::vector<Mesh::VertexHandle> verts;
std::vector<Mesh::ElementHandle> elems;
myMesh.get_all_vertices(verts, err);
CPPUNIT_ASSERT(!err);
CPPUNIT_ASSERT_EQUAL( (size_t)64, verts.size() );
myMesh.get_all_elements(elems, err);
CPPUNIT_ASSERT(!err);
CPPUNIT_ASSERT_EQUAL( (size_t)num_elem, elems.size() );
// define point domains
PointDomain* pdom[8];
pdom[0] = new PointDomain( Vector3D(0,0,0) );
pdom[1] = new PointDomain( Vector3D(3,0,0) );
pdom[2] = new PointDomain( Vector3D(0,3,0) );
pdom[3] = new PointDomain( Vector3D(3,3,0) );
pdom[4] = new PointDomain( Vector3D(0,0,3) );
pdom[5] = new PointDomain( Vector3D(3,0,3) );
pdom[6] = new PointDomain( Vector3D(0,3,3) );
pdom[7] = new PointDomain( Vector3D(3,3,3) );
size_t pdidx[8] = { 0, 3, 12, 15, 48, 51, 60, 63 };
for (unsigned i = 0; i < 8; ++i) {
MsqVertex coords;
Mesh::VertexHandle h = verts[pdidx[i]];
myMesh.vertices_get_coordinates( &h, &coords, 1, err );
CPPUNIT_ASSERT(!err);
CPPUNIT_ASSERT_VECTORS_EQUAL( pdom[i]->geom(), coords, 1e-6 );
DomSet set;
set.domain = pdom[i];
set.vertices.push_back( h );
myDomains.push_back( set );
domainDims.push_back( 0 );
}
// define line domains
LineDomain* ldom[12];
ldom[0] = new LineDomain( Vector3D(0,0,0), Vector3D(1,0,0) ); // y=0,z=0
ldom[1] = new LineDomain( Vector3D(0,3,0), Vector3D(1,0,0) ); // y=3,z=0
ldom[2] = new LineDomain( Vector3D(0,0,3), Vector3D(1,0,0) ); // y=0,z=3
ldom[3] = new LineDomain( Vector3D(0,3,3), Vector3D(1,0,0) ); // y=3,z=3
ldom[4] = new LineDomain( Vector3D(0,0,0), Vector3D(0,1,0) ); // x=0,z=0
ldom[5] = new LineDomain( Vector3D(3,0,0), Vector3D(0,1,0) ); // x=3,z=0
ldom[6] = new LineDomain( Vector3D(0,0,3), Vector3D(0,1,0) ); // x=0,z=3
ldom[7] = new LineDomain( Vector3D(3,0,3), Vector3D(0,1,0) ); // x=3,z=3
ldom[8] = new LineDomain( Vector3D(0,0,0), Vector3D(0,0,1) ); // x=0,y=0
ldom[9] = new LineDomain( Vector3D(3,0,0), Vector3D(0,0,1) ); // x=3,y=0
ldom[10]= new LineDomain( Vector3D(0,3,0), Vector3D(0,0,1) ); // x=0,y=3
ldom[11]= new LineDomain( Vector3D(3,3,0), Vector3D(0,0,1) ); // x=3,y=3
size_t ldidx[12][2] = { { 1, 2 }, { 13, 14 }, { 49, 50 }, { 61, 62 },
{ 4, 8 }, { 7, 11 }, { 52, 56 }, { 55, 59 },
{ 16, 32 }, { 19, 35 }, { 28, 44 }, { 31, 47 } };
for (unsigned i = 0; i < 12; ++i) {
Mesh::VertexHandle v[2];
v[0] = verts[ldidx[i][0]];
v[1] = verts[ldidx[i][1]];
MsqVertex coords[2];
myMesh.vertices_get_coordinates( v, coords, 2, err );
CPPUNIT_ASSERT(!err);
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.0, ldom[i]->geom().distance( coords[0] ), 1e-6 );
CPPUNIT_ASSERT_DOUBLES_EQUAL( 0.0, ldom[i]->geom().distance( coords[1] ), 1e-6 );
DomSet set;
set.domain = ldom[i];
set.vertices.push_back(v[0]);
set.vertices.push_back(v[1]);
myDomains.push_back( set );
domainDims.push_back( 1 );
}
// define planar domains
PlanarDomain* sdom[6];
sdom[0] = new PlanarDomain( Vector3D( 0, 0,-1), Vector3D(0,0,0) );
sdom[1] = new PlanarDomain( Vector3D( 0, 0, 1), Vector3D(0,0,3) );
sdom[2] = new PlanarDomain( Vector3D( 0,-1, 0), Vector3D(0,0,0) );
sdom[3] = new PlanarDomain( Vector3D( 0, 1, 0), Vector3D(0,3,0) );
sdom[4] = new PlanarDomain( Vector3D(-1, 0, 0), Vector3D(0,0,0) );
sdom[5] = new PlanarDomain( Vector3D( 1, 0, 0), Vector3D(3,0,0) );
size_t sdidx[6][4] = { { 5, 6, 9, 10 }, { 53, 54, 57, 58 },
{ 17, 18, 33, 34 }, { 29, 30, 45, 46 },
{ 20, 24, 36, 40 }, { 23, 27, 39, 43 } };
for (unsigned i = 0; i < 6; ++i) {
DomSet set;
set.domain = sdom[i];
for (unsigned j = 0; j < 4; ++j)
set.vertices.push_back( verts[sdidx[i][j]] );
for (unsigned j = 0; j < 9; ++j)
set.elements.push_back( elems[9*i+j] );
myDomains.push_back( set );
domainDims.push_back( 2 );
}
// for (unsigned i = 0; i < myDomains.size(); ++i)
// print_domain( i, myDomains[i] );
}
void BCDTest::compare_bcd( ObjectiveFunction* OF, string name, const char* mesh_file )
{
MsqPrintError err(cout);
size_t i;
vector<MsqVertex> initial_coords, global_coords, bcd_coords;
vector<Mesh::VertexHandle> vertex_list;
// set up a smoother
TerminationCriterion iterations, vertex_movement;
iterations.add_iteration_limit( 2 );
vertex_movement.add_absolute_vertex_movement( 1e-3 );
SolverType global_solver( OF );
SolverType bcd_solver( OF );
global_solver.use_global_patch();
bcd_solver.use_element_on_vertex_patch();
bcd_solver.do_block_coordinate_descent_optimization();
global_solver.set_inner_termination_criterion( &vertex_movement );
bcd_solver.set_inner_termination_criterion( &iterations );
bcd_solver.set_outer_termination_criterion( &vertex_movement );
QualityAssessor qa;
qa.add_quality_assessment( &mMetric );
InstructionQueue global_q, bcd_q;
global_q.add_quality_assessor( &qa, err );
global_q.set_master_quality_improver( &global_solver, err );
global_q.add_quality_assessor( &qa, err );
bcd_q.set_master_quality_improver( &bcd_solver, err );
bcd_q.add_quality_assessor( &qa, err );
// read mesh
MeshImpl mesh;
mesh.read_vtk( mesh_file, err ); ASSERT_NO_ERROR(err);
mesh.get_all_vertices( vertex_list, err ); ASSERT_NO_ERROR(err);
CPPUNIT_ASSERT(!vertex_list.empty());
initial_coords.resize( vertex_list.size() );
mesh.vertices_get_coordinates( arrptr(vertex_list), arrptr(initial_coords), vertex_list.size(), err );
ASSERT_NO_ERROR(err);
// run global smoother
global_q.run_instructions( &mesh, err );
ASSERT_NO_ERROR(err);
mesh.write_vtk( (name + "-gbl.vtk").c_str(), err );
global_coords.resize( vertex_list.size() );
mesh.vertices_get_coordinates( arrptr(vertex_list), arrptr(global_coords), vertex_list.size(), err );
ASSERT_NO_ERROR(err);
// restore initial vertex positions
for (i = 0; i < vertex_list.size(); ++i) {
mesh.vertex_set_coordinates( vertex_list[i], initial_coords[i], err );
ASSERT_NO_ERROR(err);
}
// run local smoother
bcd_q.run_instructions( &mesh, err );
ASSERT_NO_ERROR(err);
mesh.write_vtk( (name + "-bcd.vtk").c_str(), err );
bcd_coords.resize( vertex_list.size() );
mesh.vertices_get_coordinates( arrptr(vertex_list), arrptr(bcd_coords), vertex_list.size(), err );
ASSERT_NO_ERROR(err);
// compare results
for (i = 0; i < bcd_coords.size(); ++i)
CPPUNIT_ASSERT_VECTORS_EQUAL( global_coords[i], bcd_coords[i], 1e-2 );
}