#include "Mesquite.hpp"
#include "ConditionNumberQualityMetric.hpp"
#include "IdealWeightInverseMeanRatio.hpp"
#include "LPtoPTemplate.hpp"
#include "InstructionQueue.hpp"
#include "ConjugateGradient.hpp"
#include "FeasibleNewton.hpp"
#include "MeshImpl.hpp"
#include "QualityAssessor.hpp"
#include "XYRectangle.hpp"
#include <iostream>
#include <fstream>
#include <cstdlib>

Include dependency graph for synchronous_test.cpp:

Functions
void	create_input_mesh (double mid_x, MBMesquite::MeshImpl &mesh, MBMesquite::MsqError &)
void	usage (const char *argv0, bool brief=true)
void	parse_options (char *argv[], int argc)
int	main (int argc, char *argv[])
Variables
const double	min_x = 0.0
const double	max_x = 2.0
const double	min_y = 0.0
const double	mid_y = 1.0
const double	max_y = 2.0
const double	z = 0.0
const char	default_out_file [] = "synchronous.vtk"
double	default_x = 0.25
char	mSolver = '\0'
char	mMetric = '\0'
const char *	outputFile = default_out_file
double	input_x = default_x
const char *	temp_file = "syncrononous_input.vtk"

Function Documentation

void create_input_mesh	(	double	mid_x,
		MBMesquite::MeshImpl &	mesh,
		MBMesquite::MsqError &	err
	)

Definition at line 212 of file synchronous_test.cpp.

References max_x, max_y, mid_y, min_x, min_y, MBMesquite::MeshImpl::read_vtk(), temp_file, and z.

{
    std::ofstream vtkfile( temp_file );
    vtkfile << "# vtk DataFile Version 3.0" << std::endl
            << "Mesquite Syncronous Boundary test" << std::endl
            << "ASCII" << std::endl
            << "DATASET UNSTRUCTURED_GRID" << std::endl
            << "POINTS 9 float" << std::endl
            << min_x << ' ' << max_y << ' ' << z << std::endl
            << mid_x << ' ' << max_y << ' ' << z << std::endl
            << max_x << ' ' << max_y << ' ' << z << std::endl
            << min_x << ' ' << mid_y << ' ' << z << std::endl
            << mid_x << ' ' << mid_y << ' ' << z << std::endl
            << max_x << ' ' << mid_y << ' ' << z << std::endl
            << min_x << ' ' << min_y << ' ' << z << std::endl
            << mid_x << ' ' << min_y << ' ' << z << std::endl
            << max_x << ' ' << min_y << ' ' << z << std::endl
            << "CELLS 4 20" << std::endl
            << "4 1 0 3 4" << std::endl
            << "4 2 1 4 5" << std::endl
            << "4 4 3 6 7" << std::endl
            << "4 5 4 7 8" << std::endl
            << "CELL_TYPES 4" << std::endl
            << "9 9 9 9" << std::endl
            << "POINT_DATA 9" << std::endl
            << "SCALARS fixed int" << std::endl
            << "LOOKUP_TABLE default" << std::endl
            << "1 0 1" << std::endl
            << "1 0 1" << std::endl
            << "1 0 1" << std::endl;
    vtkfile.close();

    mesh.read_vtk( temp_file, err );
    remove( temp_file );
}

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 142 of file synchronous_test.cpp.

References MBMesquite::TerminationCriterion::add_absolute_vertex_movement(), MBMesquite::InstructionQueue::add_quality_assessor(), create_input_mesh(), MBMesquite::TerminationCriterion::GNUPLOT, MBMesquite::inner(), input_x, max_x, max_y, mesh, min_x, min_y, mMetric, mSolver, MSQ_CHKERR, outputFile, parse_options(), MBMesquite::IQInterface::run_instructions(), MBMesquite::InstructionQueue::set_master_quality_improver(), MBMesquite::XYRectangle::setup(), MBMesquite::TerminationCriterion::write_mesh_steps(), and MBMesquite::MeshImpl::write_vtk().

{
    parse_options( argv, argc );

    MeshImpl mesh;
    XYRectangle domain( max_x - min_x, max_y - min_y, min_x, min_y );
    MsqError err;

    create_input_mesh( input_x, mesh, err );
    if( MSQ_CHKERR( err ) )
    {
        std::cerr << err << std::endl;
        return 2;
    }

    domain.setup( &mesh, err );
    if( MSQ_CHKERR( err ) )
    {
        std::cerr << err << std::endl;
        return 2;
    }

    QualityMetric* metric = 0;
    if( mMetric == 'c' )
        metric = new ConditionNumberQualityMetric;
    else
        metric = new IdealWeightInverseMeanRatio;

    LPtoPTemplate function( 1, metric );

    VertexMover* solver = 0;
    if( mSolver == 'j' )
        solver = new ConjugateGradient( &function );
    else
        solver = new FeasibleNewton( &function );

    if( PatchSetUser* psu = dynamic_cast< PatchSetUser* >( solver ) ) psu->use_global_patch();

    TerminationCriterion inner;
    inner.add_absolute_vertex_movement( 1e-4 );
    inner.write_mesh_steps( "synchronous", TerminationCriterion::GNUPLOT );
    solver->set_inner_termination_criterion( &inner );

    InstructionQueue q;
    QualityAssessor qa( metric, 10 );
    q.add_quality_assessor( &qa, err );
    q.set_master_quality_improver( solver, err );
    q.add_quality_assessor( &qa, err );
    MeshDomainAssoc mesh_and_domain = MeshDomainAssoc( &mesh, &domain );
    q.run_instructions( &mesh_and_domain, err );
    delete solver;
    delete metric;

    if( MSQ_CHKERR( err ) )
    {
        std::cerr << err << std::endl;
        return 3;
    }

    mesh.write_vtk( outputFile, err );
    if( MSQ_CHKERR( err ) )
    {
        std::cerr << err << std::endl;
        return 2;
    }

    return 0;
}

void parse_options	(	char *	argv[],
		int	argc
	)

Definition at line 87 of file synchronous_test.cpp.

References default_out_file, input_x, mMetric, mSolver, outputFile, and usage.

{
    bool next_arg_is_x = false;
    for( int i = 1; i < argc; ++i )
    {
        if( next_arg_is_x )
        {
            next_arg_is_x = false;
            char* endptr  = 0;
            input_x       = std::strtod( argv[i], &endptr );
            if( endptr && *endptr ) usage( argv[0] );
            continue;
        }

        if( argv[i][0] != '-' )
        {
            if( outputFile != default_out_file ) usage( argv[0] );
            outputFile = argv[i];
            continue;
        }

        for( const char* p = argv[i] + 1; *p; ++p )
        {
            switch( *p )
            {
                case 'x':
                    next_arg_is_x = true;
                    break;

                case 'j':
                case 'n':
                    if( mSolver ) usage( argv[0] );
                    mSolver = *p;
                    break;

                case 'r':
                case 'c':
                    if( mMetric ) usage( argv[0] );
                    mMetric = *p;
                    break;

                default:
                    usage( argv[0], *p != 'h' );
                    break;
            }
        }
    }

    if( next_arg_is_x ) usage( argv[0] );

    // default values
    if( !mMetric ) mMetric = 'c';
    if( !mSolver ) mSolver = 'j';
}

void usage	(	const char *	argv0,
		bool	brief = `true`
	)

Definition at line 59 of file synchronous_test.cpp.

References default_out_file, and default_x.

{
    std::ostream& str = brief ? std::cerr : std::cout;

    str << "Usage: " << argv0 << " [-x <coord>]"
        << " [-j|-n|-d]"
        << " [-r|-c]"
        << " [<output_file>]" << std::endl;
    if( brief )
    {
        str << "       " << argv0 << " -h" << std::endl;
        std::exit( 1 );
    }

    str << "  -x  Specify X coordinate value for mesh (default is " << default_x << ")" << std::endl
        << "  -j  Use ConjugateGradient solver (default)" << std::endl
        << "  -n  Use FeasibleNewton solver" << std::endl
        << "  -r  Use IdealWeightInverseMeanRation metric" << std::endl
        << "  -c  Use ConditionNumber metric (default)" << std::endl
        << "Default output file is \"" << default_out_file << '"' << std::endl;

    std::exit( 0 );
}