void setUp()
{
MsqPrintError err(cout);
// creates a quality assessor and a qualilty improver
mQM = new IdealWeightInverseMeanRatio(err);
CPPUNIT_ASSERT(!err);
mOF = new LPtoPTemplate(mQM, 2, err);
CPPUNIT_ASSERT(!err);
mQI = new SteepestDescent( mOF );
mQA = new QualityAssessor();
mQA->set_stopping_assessment( mQM );
CPPUNIT_ASSERT(!err);
}
static int do_smoother( const char* input_file,
const char* output_file,
const char* ref_mesh_file,
double of_power,
unsigned metric_idx,
AveragingScheme avg_scheme )
{
MsqPrintError err(cerr);
TargetMetric2D *const target_metric = metrics[metric_idx].u;
cout << "Input file: " << input_file << endl;
cout << "Metric: ";
if (avg_scheme != NONE)
cout << averaging_names[avg_scheme] << " average of ";
cout << metrics[metric_idx].n << endl;
cout << "Of Power: " << of_power << endl;
auto_ptr<TargetCalculator> tc;
auto_ptr<MeshImpl> ref_mesh_impl;
auto_ptr<ReferenceMesh> ref_mesh;
if (ref_mesh_file) {
ref_mesh_impl.reset(new MeshImpl);
ref_mesh_impl->read_vtk( ref_mesh_file, err );
if (MSQ_CHKERR(err)) return 2;
ref_mesh.reset( new ReferenceMesh( ref_mesh_impl.get() ));
tc.reset( new RefMeshTargetCalculator( ref_mesh.get() ) );
}
else {
tc.reset( new IdealShapeTarget( ) );
}
TMPQualityMetric jacobian_metric( tc.get(), target_metric, 0 );
ElementPMeanP elem_avg( of_power, &jacobian_metric );
VertexPMeanP vtx_avg( of_power, &jacobian_metric );
QualityMetric* mmetrics[] = { &jacobian_metric, &elem_avg, &vtx_avg, &jacobian_metric };
QualityMetric* metric = mmetrics[avg_scheme];
TerminationCriterion outer, inner;
outer.add_iteration_limit( 1 );
inner.add_absolute_vertex_movement( 1e-4 );
inner.add_iteration_limit( 100 );
PMeanPTemplate obj1( of_power, metric );
PatchPowerMeanP obj2( of_power, metric );
ObjectiveFunction& objective = *((avg_scheme == PATCH) ? (ObjectiveFunction*)&obj2 : (ObjectiveFunction*)&obj1);
ConjugateGradient solver( &objective, err );
if (MSQ_CHKERR(err)) return 1;
solver.set_inner_termination_criterion( &inner );
solver.set_outer_termination_criterion( &outer );
solver.use_global_patch();
ConditionNumberQualityMetric qm_metric;
QualityAssessor assessor;
assessor.add_quality_assessment( metric, 10 );
assessor.add_quality_assessment( &qm_metric );
InstructionQueue q;
q.add_quality_assessor( &assessor, err );
q.set_master_quality_improver( &solver, err );
q.add_quality_assessor( &assessor, err );
MeshImpl mesh;
mesh.read_vtk( input_file, err );
if (MSQ_CHKERR(err)) return 2;
PlanarDomain geom = make_domain( &mesh, err );
if (MSQ_CHKERR(err)) return 1;
q.run_instructions( &mesh, &geom, err );
if (MSQ_CHKERR(err)) return 3;
mesh.write_vtk( output_file, err );
if (MSQ_CHKERR(err)) return 2;
cout << "Wrote: " << output_file << endl;
return 0;
}
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 );
}
