gqt_findvol_test.cpp

Go to the documentation of this file.

#include <iostream>
#include "moab/Interface.hpp"
#ifndef IS_BUILDING_MB
#define IS_BUILDING_MB
#endif
#include "TestUtil.hpp"
#include "Internals.hpp"
#include "moab/Core.hpp"

#include "moab/GeomQueryTool.hpp"
#include "moab/GeomTopoTool.hpp"

using namespace moab;

Core* MBI;
GeomTopoTool* GTT;
GeomQueryTool* GQT;

Tag id_tag = 0;

const std::string input_file = TestDir + "unittest/find_vol_test_geom.h5m";

void find_volume_tests();

int main()
{

    MBI            = new Core();
    ErrorCode rval = MBI->load_file( input_file.c_str() );MB_CHK_SET_ERR( rval, "Failed to load test file" );

    GTT = new GeomTopoTool( MBI );
    GQT = new GeomQueryTool( GTT );

    // initialize the rest of the GQT
    GQT->initialize();

    int result = 0;

    // with no global OBB tree (will defer to find_volume_slow)
    result += RUN_TEST( find_volume_tests );

    // build OBBs with one-vol tree
    GTT->construct_obb_trees( true );

    // using the global OBB tree
    result += RUN_TEST( find_volume_tests );

    return result;
}

ErrorCode id_lookup( EntityHandle eh, int& id )
{
    ErrorCode rval;
    if( !id_tag )
    {
        id_tag = MBI->globalId_tag();
    }

    rval = MBI->tag_get_data( id_tag, &eh, 1, (void*)&id );MB_CHK_SET_ERR( rval, "Failed to lookup volume id" );

    return MB_SUCCESS;
}

// Test case structure
// It is possible in some cases
// to have 2 correct answers (overlaps)
// A result of zero means no volume should be found

struct FindVolTestResult
{
    double pnt[3];
    double dir[3];
    int resultA;
    int resultB;
};

// Test Geometry
//
// The test geometry consists of 3 cubes, one of which
// overlaps another. Volumes 1 and 2 have edges with
// length 1. Volume 3 has an edge length of 0.5.
// Volume 1 is centered at (3, 0, 0). Volume 2 is
// centered on the origin. Volume 3 is centered on (0.5, 0, 0).
// Volume 4 is the implicit complement.
//
// XY slice of geometry:
//
// ###########################                   #############################
// #                         #                   #                           #
// #                         #                   #                           #
// #                ####################         #                           #
// #                #        #         #         #                           #
// #      Vol 2     #        #  Vol 3  #         #           Vol 1           #
// #                #        #         #         #                           #
// #                #        #         #         #                           #
// #                ####################         #                           #
// #                         #                   #                           #
// #                         #     Vol 4 (IC)    #                           #
// ###########################                   #############################

void find_volume_tests()
{

    ErrorCode rval;

    const struct FindVolTestResult tests[] = {
        // one point unambiguously placed in each volume
        // and the implicit complement
        { { -0.1, 0.0, 0.0 }, { 0.0, 0.0, 0.0 }, 2, 4 },   // 1
        { { 0.6, 0.0, 0.0 }, { 0.0, 0.0, 0.0 }, 3, 4 },    // 2
        { { 3.0, 0.0, 0.0 }, { 0.0, 0.0, 0.0 }, 1, -1 },   // 3
        { { -5.0, 0.0, 0.0 }, { 0.0, 0.0, 0.0 }, 0, -1 },  // 4
        // Point on the negative side of the geometry
        { { -5.0, 0.0, 0.0 }, { 1.0, 0.0, 0.0 }, 0, -1 },   // 5
        { { -5.0, 0.0, 0.0 }, { -1.0, 0.0, 0.0 }, 0, -1 },  // 6
        // Point on the positive side of the geometry
        { { 10.0, 0.0, 0.0 }, { 0.0, 0.0, 0.0 }, 0, -1 },   // 7
        { { 10.0, 0.0, 0.0 }, { -1.0, 0.0, 0.0 }, 0, -1 },  // 8
        { { 10.0, 0.0, 0.0 }, { 1.0, 0.0, 0.0 }, 0, -1 },   // 9
        // Point between the volumes
        { { 1.5, 0.0, 0.0 }, { 0.0, 0.0, 0.0 }, 0, 4 },    // 10
        { { 1.5, 0.0, 0.0 }, { -1.0, 0.0, 0.0 }, 4, -1 },  // 11
        { { 1.5, 0.0, 0.0 }, { 1.0, 0.0, 0.0 }, 4, -1 },   // 12
        { { 1.5, 0.0, 0.0 }, { 0.0, 1.0, 0.0 }, 0, -1 },   // 13
        // Point in the overlap of vols 2 & 3
        { { 0.4, 0.0, 0.0 }, { 0.0, 0.0, 0.0 }, 2, 3 },   // 14
        { { 0.4, 0.0, 0.0 }, { -1.0, 0.0, 0.0 }, 2, 3 },  // 15
        { { 0.4, 0.0, 0.0 }, { 1.0, 0.0, 0.0 }, 2, 3 },   // 16
        // Point in Vol 3 w/ different directions applied
        { { 0.6, 0.0, 0.0 }, { 0.0, 0.0, 0.0 }, 3, 4 },   // 17
        { { 0.6, 0.0, 0.0 }, { -1.0, 0.0, 0.0 }, 3, 4 },  // 18
        { { 0.6, 0.0, 0.0 }, { 1.0, 0.0, 0.0 }, 3, 4 },   // 19
        // Point on surface of volume 1 w/ tangent direction
        { { 3.0, 0.5, 0.0 }, { 1.0, 0.0, 0.0 }, 1, -1 },   // 20
        { { 3.0, 0.5, 0.0 }, { -1.0, 0.0, 0.0 }, 1, -1 },  // 21
        // Point on surface of volume 1 w/ non-tangent direction
        { { 3.0, 0.5, 0.0 }, { 0.0, 1.0, 0.0 }, 1, -1 },   // 22
        { { 3.0, 0.5, 0.0 }, { 0.0, -1.0, 0.0 }, 4, -1 },  // 23
        // Checks that the neg ray distance doesn't affect results
        // Location: Positive Y Surface of Volume 2
        { { 0.6, 0.25000000000001, 0.0 }, { 0.0, 1.0, 0.0 }, 4, 0 },    // 24
        { { 0.6, 0.25000000000001, 0.0 }, { 0.0, -1.0, 0.0 }, 4, -1 },  // 25
        // ON-SURFACE POINT TESTS (not checked using PIV loop)
        // Point on surface of volume 1 w/ random directions
        { { 3.0, 0.5, 0.0 }, { 0.0, 0.0, 0.0 }, 1, 4 },  // 26
        // Point on surface of volume 2 w/ random directions
        { { 0.6, 0.23, 0.0 }, { 0.0, 0.0, 0.0 }, 3, 4 }  // 27
    };

    int num_tests = sizeof( tests ) / sizeof( FindVolTestResult );

    EntityHandle volume_found;
    int vol_id;

    bool using_find_volume_slow = GTT->get_one_vol_root() == 0;

    // Skip the last two tests
    if( using_find_volume_slow )
    {
        std::cout << "Skipping last two tests when"
                  << "using find_volume_slow (PIV loop)" << std::endl;
        num_tests -= 2;
    }

    for( int i = 1; i < num_tests + 1; i++ )
    {
        const FindVolTestResult& test = tests[i - 1];

        const double* direction = NULL;
        if( test.dir[0] != 0.0 || test.dir[1] != 0.0 || test.dir[2] != 0.0 )
        {
            direction = test.dir;
        }

        // if we're testing a random direction, run the test many times
        int num_repeats = direction ? 1 : 100;
        for( int j = 0; j < num_repeats; j++ )
        {
            rval = GQT->find_volume( test.pnt, volume_found, direction );
            // if not found, we will check later
            if( rval != MB_ENTITY_NOT_FOUND )
            {
                MB_CHK_SET_ERR_CONT( rval, "Failed in find_volume" );
            }

            rval = id_lookup( volume_found, vol_id );MB_CHK_SET_ERR_CONT( rval, "Failed in id lookup" );

            std::cout << "Test " << i << ". Volume found id: " << vol_id << "\n";
            // make sure at least one of these checks passed
            CHECK( vol_id == test.resultA || vol_id == test.resultB );

            // reset result and id for safety
            volume_found = 0;
            vol_id       = -1;
        }  // repeat loop
    }      // test loop
}