MOAB: Mesh Oriented datABase  (version 5.3.0)
2d_target_test.cpp File Reference
#include "Mesquite.hpp"
#include <iostream>
#include <memory>
#include <cctype>
#include "MeshImpl.hpp"
#include "MsqError.hpp"
#include "InstructionQueue.hpp"
#include "TerminationCriterion.hpp"
#include "QualityAssessor.hpp"
#include "PMeanPTemplate.hpp"
#include "PatchPowerMeanP.hpp"
#include "ConjugateGradient.hpp"
#include "PlanarDomain.hpp"
#include "IdealShapeTarget.hpp"
#include "ConditionNumberQualityMetric.hpp"
#include "ReferenceMesh.hpp"
#include "RefMeshTargetCalculator.hpp"
#include "TestUtil.hpp"
#include "TQualityMetric.hpp"
#include "ElementPMeanP.hpp"
#include "VertexPMeanP.hpp"
#include "TSquared.hpp"
#include "TShapeNB1.hpp"
#include "TShapeB1.hpp"
#include "TShapeOrientNB1.hpp"
#include "TShapeOrientNB2.hpp"
#include "TShapeOrientB1.hpp"
#include "TShapeSize2DNB1.hpp"
#include "TShapeSizeB1.hpp"
#include "TShapeSize2DB2.hpp"
#include "TShapeSizeB3.hpp"
#include "TShapeSizeOrientNB1.hpp"
#include "TShapeSizeOrientB1.hpp"
#include "TShapeSizeOrientB2.hpp"
+ Include dependency graph for 2d_target_test.cpp:

Go to the source code of this file.

Enumerations

enum  AveragingScheme { NONE = 0, ELEMENT, VERTEX, PATCH }

Functions

static PlanarDomain make_domain (Mesh *mesh, MsqError &)
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)
static void usage (const char *argv0, bool help=false)
static void check_next_arg (int argc, char *argv[], int &i)
static double parse_double (int argc, char *argv[], int &i)
static int comp_string_start (const char *p, const char *s)
static AveragingScheme parse_averaging (int argc, char *argv[], int &i)
static unsigned parse_metric (int argc, char *argv[], int &i)
static void list_metrics ()
int main (int argc, char *argv[])

Variables

struct {
   TMetric *   u
   const char *   n
metrics []
const char *const averaging_names [] = { "none", "element", "vertex", "patch" }
const double DEFAULT_OF_POWER = 1.0
const unsigned DEFAULT_METRIC_IDX = 0
const AveragingScheme DEFAULT_AVG_SCHEME = NONE
std::string DEFAULT_INPUT_FILE = "/2D/vtk/quads/untangled/quads_4by2_bad.vtk"
std::string DEFAULT_OUTPUT_FILE = "./out.vtk"

Enumeration Type Documentation

Enumerator:
NONE 
ELEMENT 
VERTEX 
PATCH 

Definition at line 91 of file 2d_target_test.cpp.

{
    NONE = 0,
    ELEMENT,
    VERTEX,
    PATCH
};

Function Documentation

static void check_next_arg ( int  argc,
char *  argv[],
int &  i 
) [static]

Definition at line 256 of file 2d_target_test.cpp.

References usage.

Referenced by main(), parse_averaging(), parse_double(), and parse_metric().

{
    if( i == argc )
    {
        cerr << "Expected argument following \"" << argv[i] << '"' << endl;
        usage( argv[0] );
    }
    ++i;
}
static int comp_string_start ( const char *  p,
const char *  s 
) [static]

Definition at line 279 of file 2d_target_test.cpp.

Referenced by parse_averaging(), and parse_metric().

{
    int i;
    for( i = 0; p[i]; ++i )
        if( tolower( p[i] ) != tolower( s[i] ) ) return 0;
    return s[i] ? -1 : 1;
}
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 
) [static]

Definition at line 109 of file 2d_target_test.cpp.

References MBMesquite::TerminationCriterion::add_absolute_vertex_movement(), MBMesquite::TerminationCriterion::add_iteration_limit(), MBMesquite::QualityAssessor::add_quality_assessment(), MBMesquite::InstructionQueue::add_quality_assessor(), averaging_names, geom, MBMesquite::inner(), make_domain(), mesh, metrics, MSQ_CHKERR, MBMesquite::NONE, MBMesquite::outer(), PATCH, MBMesquite::MeshImpl::read_vtk(), MBMesquite::IQInterface::run_instructions(), MBMesquite::QualityAssessor::scale_histograms(), MBMesquite::QualityImprover::set_inner_termination_criterion(), MBMesquite::InstructionQueue::set_master_quality_improver(), MBMesquite::QualityImprover::set_outer_termination_criterion(), MBMesquite::PatchSetUser::use_global_patch(), and MBMesquite::MeshImpl::write_vtk().

Referenced by main().

{
    MsqPrintError err( cerr );

    TMetric* 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;

    unique_ptr< TargetCalculator > tc;
    unique_ptr< MeshImpl > ref_mesh_impl;
    unique_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() );
    }

    TQualityMetric jacobian_metric( tc.get(), target_metric );
    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 before_assessor;
    QualityAssessor after_assessor;
    before_assessor.add_quality_assessment( metric, 10 );
    before_assessor.add_quality_assessment( &qm_metric );
    after_assessor.add_quality_assessment( metric, 10 );

    InstructionQueue q;
    q.add_quality_assessor( &before_assessor, err );
    q.set_master_quality_improver( &solver, err );
    q.add_quality_assessor( &after_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;
    MeshDomainAssoc mesh_and_domain = MeshDomainAssoc( &mesh, &geom );
    q.run_instructions( &mesh_and_domain, err );
    if( MSQ_CHKERR( err ) ) return 3;
    mesh.write_vtk( output_file, err );
    if( MSQ_CHKERR( err ) ) return 2;
    cout << "Wrote: " << output_file << endl;

    before_assessor.scale_histograms( &after_assessor );

    return 0;
}
static void list_metrics ( ) [static]

Definition at line 335 of file 2d_target_test.cpp.

References metrics, and n.

Referenced by main().

{
    cout << "Available metrics:" << endl;
    for( unsigned j = 0; metrics[j].u; ++j )
        cout << "\t" << metrics[j].n << endl;
    exit( 0 );
}
int main ( int  argc,
char *  argv[] 
)

Definition at line 343 of file 2d_target_test.cpp.

References check_next_arg(), DEFAULT_AVG_SCHEME, DEFAULT_INPUT_FILE, DEFAULT_METRIC_IDX, DEFAULT_OF_POWER, DEFAULT_OUTPUT_FILE, do_smoother(), input_file, list_metrics(), parse_averaging(), parse_double(), parse_metric(), and usage.

{
    MsqPrintError err( cout );

    // CL settings
    double of_power            = DEFAULT_OF_POWER;
    unsigned metric_idx        = DEFAULT_METRIC_IDX;
    AveragingScheme avg_scheme = DEFAULT_AVG_SCHEME;
    const char* input_file     = 0;
    const char* output_file    = 0;
    const char* ref_mesh_file  = 0;

    bool proc_opts = true;
    for( int i = 1; i < argc; ++i )
    {
        if( !proc_opts || argv[i][0] != '-' )
        {
            if( output_file )
            {
                cerr << "Unexpected file name: \"" << argv[i] << '"' << endl;
                usage( argv[0] );
            }
            else if( input_file )
                output_file = argv[i];
            else
                input_file = argv[i];
            continue;
        }

        if( !argv[i][1] || argv[i][2] )
        {
            cerr << "Invalid option: \"" << argv[i] << '"' << endl;
            usage( argv[0] );
        }

        switch( argv[i][1] )
        {
            case 'p':
                of_power = parse_double( argc, argv, i );
                break;
            case 'm':
                metric_idx = parse_metric( argc, argv, i );
                break;
            case 'a':
                avg_scheme = parse_averaging( argc, argv, i );
                break;
            case 'r':
                check_next_arg( argc, argv, i );
                ref_mesh_file = argv[i];
                break;
            case '-':
                proc_opts = false;
                break;
            case 'h':
                usage( argv[0], true );
                break;
            case 'l':
                list_metrics();
                break;
            default:
                cerr << "Invalid option: \"" << argv[i] << '"' << endl;
                usage( argv[0] );
        }
    }

    if( !input_file ) input_file = DEFAULT_INPUT_FILE.c_str();
    if( !output_file ) output_file = DEFAULT_OUTPUT_FILE.c_str();

    return do_smoother( input_file, output_file, ref_mesh_file, of_power, metric_idx, avg_scheme );
}
static PlanarDomain make_domain ( Mesh mesh,
MsqError err 
) [static]

Definition at line 187 of file 2d_target_test.cpp.

References MBMesquite::arrptr(), MBMesquite::Mesh::get_all_vertices(), MBMesquite::MsqError::INVALID_STATE, MSQ_CHKERR, MSQ_SETERR, and MBMesquite::Mesh::vertices_get_coordinates().

Referenced by do_smoother().

{
    // calculate bounding box of mesh vertices
    Vector3D minimum( HUGE_VAL, HUGE_VAL, HUGE_VAL );
    Vector3D maximum( -HUGE_VAL, -HUGE_VAL, -HUGE_VAL );
    std::vector< Mesh::VertexHandle > vertices;
    mesh->get_all_vertices( vertices, err );
    if( MSQ_CHKERR( err ) ) { return PlanarDomain( minimum, maximum ); }
    if( vertices.empty() )
    {
        std::cerr << "Mesh contains no vertices" << std::endl;
        exit( 1 );
    }
    std::vector< MsqVertex > coords( vertices.size() );
    mesh->vertices_get_coordinates( arrptr( vertices ), arrptr( coords ), vertices.size(), err );
    if( MSQ_CHKERR( err ) ) { return PlanarDomain( minimum, maximum ); }
    std::vector< MsqVertex >::const_iterator i;
    for( i = coords.begin(); i != coords.end(); ++i )
    {
        const MsqVertex& v = *i;
        for( unsigned j = 0; j < 3; ++j )
        {
            if( v[j] < minimum[j] ) minimum[j] = v[j];
            if( v[j] > maximum[j] ) maximum[j] = v[j];
        }
    }

    // Look for a "zero" plane
    int k;
    maximum -= minimum;
    for( k = 2; k >= 0 && maximum[k] > 1e-6; --k )
        ;
    if( k < 0 )
    {
        MSQ_SETERR( err )( "Cannot determine plane of mesh.", MsqError::INVALID_STATE );
        return PlanarDomain( minimum, maximum );
    }

    Vector3D point( 0.0, 0.0, 0.0 ), normal( 0.0, 0.0, 0.0 );
    normal[k] = 1.0;
    point[k]  = minimum[k];
    return PlanarDomain( normal, point );
}
static AveragingScheme parse_averaging ( int  argc,
char *  argv[],
int &  i 
) [static]

Definition at line 287 of file 2d_target_test.cpp.

References averaging_names, check_next_arg(), comp_string_start(), MBMesquite::NONE, and usage.

Referenced by main().

{
    check_next_arg( argc, argv, i );
    for( unsigned j = 0; j < 4; ++j )
        if( comp_string_start( argv[i], averaging_names[j] ) ) return (AveragingScheme)j;
    cerr << "Expected one of { ";
    for( unsigned j = 0; j < 4; ++j )
        cerr << '"' << averaging_names[j] << "\" ";
    cerr << "} following \"" << argv[i - 1] << '"' << endl;
    usage( argv[0] );
    return NONE;
}
static double parse_double ( int  argc,
char *  argv[],
int &  i 
) [static]

Definition at line 266 of file 2d_target_test.cpp.

References check_next_arg(), and usage.

Referenced by main().

{
    check_next_arg( argc, argv, i );
    char* endptr;
    double result = strtod( argv[i], &endptr );
    if( endptr == argv[i] || *endptr )
    {
        cerr << "Expected real number following \"" << argv[i - 1] << '"' << endl;
        usage( argv[0] );
    }
    return result;
}
static unsigned parse_metric ( int  argc,
char *  argv[],
int &  i 
) [static]

Definition at line 300 of file 2d_target_test.cpp.

References check_next_arg(), comp_string_start(), metrics, n, and usage.

Referenced by main().

{
    check_next_arg( argc, argv, i );
    unsigned part = 0, all = 0, count = 0, have_all = 0;
    for( unsigned j = 0; metrics[j].u; ++j )
    {
        if( unsigned k = comp_string_start( argv[i], metrics[j].n ) )
        {
            if( k > 0 )
            {
                all      = j;
                have_all = 1;
            }
            else
            {
                part = j;
                ++count;
            }
        }
    }

    if( have_all ) return all;

    if( count )
    {
        if( count == 1 ) return part;
        cerr << "Ambiguous metric name: \"" << argv[i] << '"' << endl;
        usage( argv[0] );
    }

    cerr << "Invalid metric name following \"" << argv[i - 1] << "\" option" << endl;
    usage( argv[0] );
    return (unsigned)-1;
}
static void usage ( const char *  argv0,
bool  help = false 
) [static]

Definition at line 231 of file 2d_target_test.cpp.

References averaging_names, DEFAULT_AVG_SCHEME, DEFAULT_INPUT_FILE, DEFAULT_METRIC_IDX, DEFAULT_OF_POWER, DEFAULT_OUTPUT_FILE, help(), and metrics.

{
    ostream& str = help ? cout : cerr;
    str << argv0 << " [-p <power>] [-m metric_name] [-a averaging] [-e]"
        << " -r [ref_mesh] [input_file] [output_file]" << endl
        << argv0 << " <-l|-h>" << std::endl;
    if( help )
    {
        str << "     -p  : specify exponent value for p-mean^p OF template (default: " << DEFAULT_OF_POWER << ")"
            << endl
            << "     -m  : specify 2D target metric to use (default: " << metrics[DEFAULT_METRIC_IDX].n << ")" << endl
            << "     -a  : specify metric averaging scheme (default: " << averaging_names[DEFAULT_AVG_SCHEME] << ")"
            << endl
            << "              (none,vertex,element,patch)" << endl
            << "     -e  : sample at mid-edge points (default is corners only)" << endl
            << "     -r  : use reference mesh instead of ideal elements for targets" << endl
            << "     -l  : list available metrics" << endl
            << "     -h  : this help output" << endl
            << " default input file:  " << DEFAULT_INPUT_FILE << endl
            << " default output file: " << DEFAULT_OUTPUT_FILE << endl
            << endl;
    }
    exit( !help );
}

Variable Documentation

const char* const averaging_names[] = { "none", "element", "vertex", "patch" }

Definition at line 98 of file 2d_target_test.cpp.

Referenced by do_smoother(), parse_averaging(), and usage().

Definition at line 103 of file 2d_target_test.cpp.

Referenced by main(), and usage().

std::string DEFAULT_INPUT_FILE = "/2D/vtk/quads/untangled/quads_4by2_bad.vtk"

Definition at line 104 of file 2d_target_test.cpp.

const unsigned DEFAULT_METRIC_IDX = 0

Definition at line 102 of file 2d_target_test.cpp.

Referenced by main(), and usage().

const double DEFAULT_OF_POWER = 1.0

Definition at line 101 of file 2d_target_test.cpp.

Referenced by main(), and usage().

std::string DEFAULT_OUTPUT_FILE = "./out.vtk"

Definition at line 105 of file 2d_target_test.cpp.

Referenced by main(), and usage().

struct { ... } metrics[] [static]
const char* n
Examples:
CrystalRouterExample.cpp.

Definition at line 75 of file 2d_target_test.cpp.

Referenced by allocate_matrix(), moab::WriteSTL::ascii_write_triangles(), moab::WriteHDF5::assign_ids(), MBMesquite::PMeanPMetric::average_with_Hessian_diagonal(), moab::GeomUtil::box_tri_overlap(), moab::BoxPlaneIter::BoxPlaneIter(), moab::MeshGeneration::BrickInstance(), moab::BVHTree::build_tree(), MBMesquite::ArrayMesh::build_vertex_adjacency_list(), AveragingQMTest::check_average_and_weights(), MBMesquite::CompareQM::check_hess(), check_no_slaved_corners(), moab::WriteHDF5Parallel::check_serial_tag_data(), check_valid_adj_list(), check_valid_parents_children(), check_valid_set_contents(), moab::ParallelComm::clean_shared_tags(), moab::GeomUtil::closest_location_on_polygon(), TriStats::commafy(), moab::WriteHDF5Parallel::communicate_shared_set_ids(), moab::ParCommGraph::compute_partition(), contains_duplicates(), create_hex_mesh(), MBMesquite::create_ideal_element_patch(), create_mesh(), create_mesh_in_memory(), moab::WriteHDF5Parallel::create_tag_tables(), create_unitsq_quads(), create_unitsq_tris(), diff_2d_vect(), diff_vect(), distance_from_origin(), LinearMappingFunctionTest::do_coeff_test(), LinearMappingFunctionTest::do_deriv_test(), dump_set_ranges(), moab::SmoothFace::DumpModelControlPoints(), moab::SpectralQuad::evalFcn(), MBMesquite::TShapeSizeB3::evaluate(), MBMesquite::AffineMapMetric::evaluate(), MBMesquite::VarianceTemplate::evaluate(), MBMesquite::IdealWeightMeanRatio::evaluate(), MBMesquite::IdealWeightInverseMeanRatio::evaluate(), MBMesquite::ConicDomain::evaluate(), moab::element_utility::Spectral_hex_map< moab::Matrix3 >::evaluate(), moab::Element::SpectralHex::evaluate(), moab::Element::SpectralQuad::evaluate(), moab::element_utility::Spectral_hex_map< moab::Matrix3 >::evaluate_scalar_field(), moab::Element::SpectralHex::evaluate_scalar_field(), moab::Element::SpectralQuad::evaluate_scalar_field(), MBMesquite::TMPQualityMetric::evaluate_surface_common(), MBMesquite::TShapeSizeB3::evaluate_with_grad(), MBMesquite::VarianceTemplate::evaluate_with_gradient(), MBMesquite::IdealWeightMeanRatio::evaluate_with_gradient(), MBMesquite::IdealWeightInverseMeanRatio::evaluate_with_gradient(), MBMesquite::TShapeSizeB3::evaluate_with_hess(), MBMesquite::AddQualityMetric::evaluate_with_Hessian(), MBMesquite::PatchPowerMeanP::evaluate_with_Hessian(), MBMesquite::IdealWeightMeanRatio::evaluate_with_Hessian(), MBMesquite::AWQualityMetric::evaluate_with_Hessian(), MBMesquite::TQualityMetric::evaluate_with_Hessian(), MBMesquite::PowerQualityMetric::evaluate_with_Hessian(), MBMesquite::LPtoPTemplate::evaluate_with_Hessian(), MBMesquite::IdealWeightInverseMeanRatio::evaluate_with_Hessian(), MBMesquite::MultiplyQualityMetric::evaluate_with_Hessian(), MBMesquite::PMeanPTemplate::evaluate_with_Hessian(), MBMesquite::VarianceTemplate::evaluate_with_Hessian_diagonal(), MBMesquite::IdealWeightMeanRatio::evaluate_with_Hessian_diagonal(), MBMesquite::IdealWeightInverseMeanRatio::evaluate_with_Hessian_diagonal(), MBMesquite::ElementQM::evaluate_with_indices(), MBMesquite::AffineMapMetric::evaluate_with_indices(), FauxMetric< B >::evaluate_with_indices(), find_block(), TopologyInfoTest::find_face(), TopologyInfoTest::find_side(), find_side(), moab::Skinner::find_skin_vertices_1D(), moab::Intx2MeshInPlane::findNodes(), moab::IntxRllCssphere::findNodes(), moab::Intx2MeshOnSphere::findNodes(), findpt_list_sort(), MBMesquite::PlanarDomain::fit_vertices(), gauss_nodes(), gauss_to_legendre(), gauss_to_legendre_t(), gauss_weights(), geometric_mean(), get_boundary_vertices(), MBMesquite::MsqMeshEntity::get_connected_vertices(), get_edge_lengths(), get_expected_ghosts(), QualityMetricTester::get_ideal_element(), moab::RefinerTagManager::get_input_gids(), CompareMetric::get_mask_axis(), CompareMetric::get_name(), moab::BSPTreeBoxIter::get_neighbors(), QualityMetricTester::get_nonideal_element(), moab::RefinerTagManager::get_output_gids(), moab::MeshSetSequence::get_parent_child_meshsets(), moab::ParallelComm::get_part_neighbor_ids(), MBMesquite::TargetCalculator::get_refmesh_Jacobian_2D(), MBMesquite::TargetCalculator::get_refmesh_Jacobian_3D(), get_slaved_coords(), moab::gs_data::gs_data_op_many(), hash_index_2(), hash_index_3(), hash_setfac_2(), hash_setfac_3(), heappermute(), moab::ElemUtil::hex_eval(), how_many_numbers(), iMeshP_getNumPartNborsArr(), iMeshP_getPartNborsArr(), MBMesquite::MeshWriter::Projection::init(), GaussIntegration::initialize(), moab::gs_data::initialize(), inner(), MBMesquite::inner(), MBMesquite::inner_product(), moab::Range::insert_list(), moab::element_utility::Spectral_hex_map< moab::Matrix3 >::integrate_scalar_field(), MBMesquite::is_side_boundary(), MBMesquite::TargetCalculator::jacobian_2D(), MBMesquite::TargetCalculator::jacobian_3D(), lagrange_0(), lagrange_1(), lagrange_2(), lagrange_2u(), lagrange_setup(), lagrange_weights(), lagrange_weights_deriv(), legendre(), legendre_d1(), legendre_d2(), legendre_matrix(), legendre_row_even(), MBMesquite::length_squared(), moab::TempestOnlineMap::LinearRemapSE4_Tempest_MOAB(), MBMesquite::Linf(), list_max(), list_metrics(), list_min(), moab::ReadSms::load_file_impl(), lob_bnd_base_alloc(), lob_bnd_base_setup(), lob_bnd_ext_alloc(), lobatto_nodes_aux(), lobatto_to_legendre(), lobatto_weights(), main(), moab::Element::Map::Map(), mb_adjacent_vertex_test(), mb_skin_full_common(), mb_skin_subset_common(), mb_upward_adjacencies_test(), merge_ranges(), moab::ElemUtil::nat_coords_trilinear_hex2(), MBMesquite::PatchData::non_slave_node_set(), obbox_calc_tfm_2(), opt_area_intp_2(), opt_edge_hess_2(), opt_edge_hess_3(), opt_edge_intp_2(), opt_edge_intp_3(), opt_vol_intp_3(), MBMesquite::SmartLaplacianSmoother::optimize_vertex_positions(), MBMesquite::LaplacianSmoother::optimize_vertex_positions(), moab::pack_tuples(), parse_metric(), PartMap::part_from_coords(), MBMesquite::plus_eq_scaled(), pmean(), MBMesquite::pmean_corner_diagonals(), MBMesquite::pmean_corner_hessians(), moab::AdaptiveKDTree::print(), moab::Core::print_database(), MBMesquite::project_to_perp_plane(), quad_all_in_xy_plane(), moab::range_to_blocked_list_templ(), moab::range_to_id_list_templ(), moab::ReadNASTRAN::read_element(), read_numbers(), moab::ReadHDF5::read_var_len_tag(), moab::TempestOnlineMap::ReadParallelMap(), moab::SimplexTemplateRefiner::refine_entity(), refl(), moab::TypeSequenceManager::replace_subsequence(), run_smoother(), MBMesquite::MeshImpl::set_skin_flags(), moab::ParCommGraph::settle_comm_by_ids(), moab::ParCommGraph::settle_send_graph(), MBMesquite::CylinderDomain::snap_to(), MBMesquite::ConicDomain::snap_to(), moab::CN::SubEntityVertexIndices(), MBMesquite::sum_corner_diagonals(), MBMesquite::sum_corner_hessians(), sum_of_ratios_squared(), sum_sqr(), MBMesquite::sum_sqr_corner_diagonals(), MBMesquite::sum_sqr_corner_hessians(), tag_vals_from_gid(), tensor_c3(), tensor_r3(), TopologyInfoTest::test_adj(), MsqMeshEntityTest::test_all_nodes(), SphericalDomainTest::test_closest_point(), TetLagrangeShapeTest::test_corner_coeff(), TriLagrangeShapeTest::test_corner_derivs(), TetLagrangeShapeTest::test_corner_derivs(), test_create_ghost_ents(), test_create_tag(), test_create_var_len_tag(), PMeanPTemplateTest::test_diagonal(), QualityMetricTester::test_diagonal_with_fixed_vertex(), TetLagrangeShapeTest::test_edge_coeff(), TriLagrangeShapeTest::test_edge_derivs(), TetLagrangeShapeTest::test_edge_derivs(), TetLagrangeShapeTest::test_face_coeff(), TetLagrangeShapeTest::test_face_derivs(), test_get_set(), QualityMetricTester::test_gradient_reflects_quality(), QualityMetricTester::test_gradient_with_fixed_vertex(), PMeanPTemplateTest::test_Hessian(), QualityMetricTester::test_hessian_with_fixed_vertex(), QualityMetricTester::test_ideal_element_positive_definite_Hessian(), TetLagrangeShapeTest::test_invalid_nodebits_coeff(), TetLagrangeShapeTest::test_invalid_nodebits_deriv(), MappingFunctionTest::test_jacobian_2d(), TargetCalculatorTest::test_jacobian_2D(), MappingFunctionTest::test_jacobian_3d(), TargetCalculatorTest::test_jacobian_3D(), QualityMetricTester::test_measures_quality(), TetLagrangeShapeTest::test_mid_coeff(), TriLagrangeShapeTest::test_mid_derivs(), TetLagrangeShapeTest::test_mid_derivs(), PatchDataTest::test_num_corners(), QualityAssessorTest::test_print_stats(), TopologyInfoTest::test_rev_adj(), IdealElementTest::test_side_height_pyr(), QualityMetricTester::test_symmetric_Hessian_diagonal_blocks(), ArrayMeshTest::test_tag_data(), IdealElementTest::test_unit_height_pyr(), IdealElementTest::test_unit_pyr(), test_unitsq_quads(), test_unitsq_tris(), MBMesquite::DomainClassifier::test_valid_classification(), test_var_length_parallel(), MBMesquite::times_eq_minus(), MBMesquite::PatchData::update_cached_normals(), moab::EntityRefiner::update_heap_size(), moab::Intx2MeshOnSphere::update_tracer_data(), FakeMesh::vertices_get_attached_elements(), FakeMesh::vertices_get_fixed_flag(), TreeValidator::visit(), MBMesquite::TMPQualityMetric::weight(), moab::WriteVtk::write_bit_tag(), moab::WriteVtk::write_data(), ProgOptions::write_man_page(), moab::WriteHDF5::write_sets(), MBMesquite::MeshWriter::write_stl(), moab::WriteVtk::write_tag(), ManPage::write_text(), and XI_face().

Definition at line 74 of file 2d_target_test.cpp.

Referenced by moab::SmoothFace::ac_at_edge(), moab::ReadUtil::assign_ids(), MBMesquite::NodeSet::bit_to_bool(), center(), check_equal(), check_geometric_set(), MBMesquite::NodeSet::clear(), MBMesquite::NodeSet::clear_bit(), moab::MeshSet::contains_entities(), count_owned_entities(), create_some_mesh(), dN0dr(), dN0ds(), dN0dt(), dN4dr(), dN6ds(), dN7dt(), moab::TagInfo::equals_default_value(), MBMesquite::TMPQualityMetric::evaluate_surface_common(), CompareMetric::evaluate_with_Hessian_diagonal(), TopologyInfoTest::find_side(), FakeTargetCalc::get_2D_target(), FakeTargetCalc::get_3D_target(), MBMesquite::get_delta_C(), moab::WriteHDF5::get_set_info(), FakeTargetCalc::get_surface_target(), MBMesquite::MeshWriter::Projection::init(), MBMesquite::Instruction::initialize_vertex_byte(), moab::IntxUtils::intersect_great_circle_arc_with_clat_arc(), moab::BSPTreeBoxIter::intersects(), lagrange_weights(), lagrange_weights_deriv(), main(), make_basic_sequence(), mb_skin_higher_order_faces_common(), mb_skin_higher_order_regions_common(), mb_temporary_test(), moab::SmoothCurve::move_to_curve(), N0(), N4(), N6(), N7(), MBMesquite::NodeSet::num_before(), MBMesquite::NodeSet::num_before_bit(), moab::GeomQueryTool::point_in_volume(), MBMesquite::popcount(), MBMesquite::NodeSet::position(), moab::SmoothCurve::position_from_u(), MBMesquite::project_to_perp_plane(), moab::range_to_blocked_list_templ(), moab::ReadHDF5::read_dense_tag(), MBMesquite::NodeSet::set_bit(), setup_mesh(), moab::BSPTreeBoxIter::side_above_plane(), moab::BSPTreeBoxIter::side_on_plane(), MeshImplTest::skin_mesh_higher_order(), MeshImplTest::skin_mesh_mixed(), moab::FBEngine::split_edge_at_point(), moab::BSPTreeBoxIter::splits(), moab::OrientedBoxTreeTool::stats(), CachingTargetTest::test_2d_target_subpatch(), CachingTargetTest::test_2d_targets_cached(), CachingTargetTest::test_3d_target_subpatch(), CachingTargetTest::test_3d_targets_cached(), test_assign_global_ids(), test_bc_sets(), test_blocks(), test_box_iterator(), test_box_tree_create(), NodeSetTest::test_clear_node(), QuadLagrangeShapeTest::test_coeff_center(), QuadLagrangeShapeTest::test_coeff_corners(), QuadLagrangeShapeTest::test_coeff_edges(), QuadLagrangeShapeTest::test_deriv_center(), QuadLagrangeShapeTest::test_deriv_corners(), QuadLagrangeShapeTest::test_deriv_edges(), QualityMetricTest::test_fixed_vertex_list(), test_geometric_sets(), test_get_by_tag(), test_get_by_tag_value(), PatchDataTestNormals::test_get_element_normals_bounded_domain(), PatchDataTestNormals::test_get_element_normals_infinite_domain(), test_iterator(), test_merge_leaf(), NodeSetTest::test_num_before(), NodeSetTest::test_num_nodes(), test_pack_sets_simple(), VtkTest::test_read_quadratic(), QualityMetricTest::test_remove_fixed_gradients(), QualityMetricTest::test_remove_fixed_hessians(), test_set_flags(), NodeSetTest::test_set_node(), test_shared_sets(), CachingTargetTest::test_surface_target_subpatch(), CachingTargetTest::test_surface_targets_cached(), ArrayMeshTest::test_tag_data(), QualityAssessorTest::test_tag_element(), QualityAssessorTest::test_tag_inverted(), QualityAssessorTest::test_tag_vertex(), test_tree_create(), test_valid_struct(), test_write_elements(), iMeshTest::testDoubleTag(), iMeshTest::testIntTag(), moab::SmoothCurve::u_from_position(), moab::BitTag::unpack(), v_tet_aspect_frobenius(), IntxUtilsCSLAM::velocity_case1(), moab::HiReconstruction::walf3d_curve_vertex_eval(), and moab::HiReconstruction::walf3d_surf_vertex_eval().

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines