void InstructionQueueTest::test_add_remove_vertex_slaver()
{
InstructionQueue q;
DummyVertexSlaver s1, s2;
MsqPrintError err( std::cerr );
CPPUNIT_ASSERT( q.get_slaved_ho_node_mode() != Settings::SLAVE_CALCULATED );
q.add_vertex_slaver( &s1, err );
ASSERT_NO_ERROR(err);
CPPUNIT_ASSERT_EQUAL( Settings::SLAVE_CALCULATED, q.get_slaved_ho_node_mode() );
q.add_vertex_slaver( &s2, err );
ASSERT_NO_ERROR(err);
CPPUNIT_ASSERT_EQUAL( Settings::SLAVE_CALCULATED, q.get_slaved_ho_node_mode() );
q.remove_vertex_slaver( &s2, err );
ASSERT_NO_ERROR(err);
CPPUNIT_ASSERT_EQUAL( Settings::SLAVE_CALCULATED, q.get_slaved_ho_node_mode() );
q.remove_vertex_slaver( &s2, err );
CPPUNIT_ASSERT(err);
err.clear();
CPPUNIT_ASSERT_EQUAL( Settings::SLAVE_CALCULATED, q.get_slaved_ho_node_mode() );
q.remove_vertex_slaver( &s1, err );
ASSERT_NO_ERROR(err);
CPPUNIT_ASSERT_EQUAL( Settings::SLAVE_ALL, q.get_slaved_ho_node_mode() );
}
int main( int argc, char* argv[] )
{
const char* input_file = DEFAULT_INPUT_FILE;
const char* output_file_base = 0;
bool expect_output_base = false;
for (int i = 1; i < argc; ++i) {
if (expect_output_base) {
output_file_base = argv[i];
expect_output_base = false;
}
else if (!strcmp(argv[i],"-o"))
expect_output_base = true;
else if (input_file != DEFAULT_INPUT_FILE)
usage(argv[0]);
else
input_file = argv[i];
}
if (expect_output_base)
usage(argv[0]);
MsqPrintError err(std::cerr);
SlaveBoundaryVertices slaver(1);
TShapeNB1 tmetric;
IdealShapeTarget target;
TQualityMetric metric( &target, &tmetric );
PMeanPTemplate of( 1.0, &metric );
SteepestDescent improver( &of );
TerminationCriterion inner;
inner.add_absolute_vertex_movement( 1e-3 );
improver.set_inner_termination_criterion( &inner );
QualityAssessor assess( &metric );
InstructionQueue q;
q.set_master_quality_improver( &improver, err );
q.add_quality_assessor( &assess, err );
TriLagrangeShape trishape;
QuadLagrangeShape quadshape;
q.set_mapping_function( &trishape );
q.set_mapping_function( &quadshape );
const int NUM_MODES = 4;
Settings::HigherOrderSlaveMode modes[NUM_MODES] =
{ Settings::SLAVE_NONE,
Settings::SLAVE_ALL,
Settings::SLAVE_CALCULATED,
Settings::SLAVE_FLAG
};
std::string names[NUM_MODES] =
{ "NONE",
"ALL",
"CALCULATED",
"FLAG" };
MeshImpl meshes[NUM_MODES];
std::vector<MeshDomainAssoc> meshes_and_domains;
bool have_slaved_flag = true;
std::vector<bool> flag(1);
for (int i = 0; i < NUM_MODES; ++i) {
std::cout << std::endl
<< "-----------------------------------------------" << std::endl
<< " Mode: " << names[i] << std::endl
<< "-----------------------------------------------" << std::endl;
meshes[i].read_vtk( input_file, err );
if (err) return 1;
if (modes[i] == Settings::SLAVE_CALCULATED) {
q.add_vertex_slaver( &slaver, err );
}
else if (modes[i] == Settings::SLAVE_FLAG) {
std::vector<Mesh::VertexHandle> verts;
meshes[i].get_all_vertices( verts, err );
if (err) return 1;
meshes[i].vertices_get_slaved_flag( arrptr(verts), flag, 1, err );
if (err) {
have_slaved_flag = false;
std::cout << "Skipped because input file does not contain slaved attribute" << std::endl;
err.clear();
continue;
}
}
if (have_slaved_flag && modes[i] == Settings::SLAVE_FLAG) {
if (!check_no_slaved_corners( meshes[i], err ) || err)
return 1;
if (!check_global_patch_slaved( meshes[i], err ) || err)
return 1;
}
PlanarDomain plane;
plane.fit_vertices( &meshes[i], err );
if (err) return 1;
q.set_slaved_ho_node_mode( modes[i] );
meshes_and_domains.push_back(MeshDomainAssoc(&meshes[i], &plane));
q.run_instructions( &meshes_and_domains[i], err );
if (err) return 1;
if (modes[i] == Settings::SLAVE_CALCULATED) {
q.remove_vertex_slaver( &slaver, err );
}
if (output_file_base) {
tag_patch_slaved( meshes[i], modes[i], err );
std::string name(output_file_base);
name += "-";
name += names[i];
name += ".vtk";
meshes[i].write_vtk( name.c_str(), err );
if (err) return 1;
}
}
int exit_code = 0;
if (input_file == DEFAULT_INPUT_FILE) {
for (int i = 0; i < NUM_MODES; ++i) {
std::cout << std::endl
<< "-----------------------------------------------" << std::endl
<< " Mode: " << names[i] << std::endl
<< "-----------------------------------------------" << std::endl;
exit_code += check_slaved_coords( meshes[i], modes[i], names[i], have_slaved_flag, err );
if (err) return 1;
}
// flags should correspond to same slaved nodes as calculated,
// so resulting meshes should be identical.
if (have_slaved_flag) {
int flag_idx = std::find( modes, modes+NUM_MODES, Settings::SLAVE_FLAG ) - modes;
int calc_idx = std::find( modes, modes+NUM_MODES, Settings::SLAVE_CALCULATED ) - modes;
exit_code += compare_node_coords( meshes[flag_idx], meshes[calc_idx], err );
if (err) return 1;
}
}
return exit_code;
}