PointIsolationAlgRandom_test.cc File Reference

Unit test with random data for PointIsolationAlg. More...

#include <boost/test/unit_test.hpp>
#include "larexamples/Algorithms/RemoveIsolatedSpacePoints/PointIsolationAlg.h"
#include "larcorealg/TestUtils/StopWatch.h"
#include "cetlib/pow.h"
#include <array>
#include <random>
#include <chrono>
#include <ratio>
#include <iostream>
#include <algorithm>

Go to the source code of this file.

Classes
struct	ArgsFixture

Macros
#define	BOOST_TEST_MODULE   ( PointIsolationAlg_test )

Functions
template<typename Engine , typename Coord = float>
void	PointIsolationTest (Engine &generator, unsigned int nPoints, std::vector< Coord > const &radii)
	BOOST_FIXTURE_TEST_CASE (PointIsolationTestCase, ArgsFixture)

Detailed Description

Unit test with random data for PointIsolationAlg.

Author

Gianluca Petrillo (petri.nosp@m.llo@.nosp@m.fnal..nosp@m.gov)

Date

June 30, 2016

See Also

PointIsolationAlg.h

This test populate datasets with random data and tests the isolation algorithm with them.

The test accepts one optional argument:

PointIsolationAlg_test  [seed]

to set the random seed to a particular value.

Definition in file PointIsolationAlgRandom_test.cc.

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( PointIsolationAlg_test )

Definition at line 21 of file PointIsolationAlgRandom_test.cc.

Function Documentation

BOOST_FIXTURE_TEST_CASE	(	PointIsolationTestCase	,
		ArgsFixture
	)

Definition at line 156 of file PointIsolationAlgRandom_test.cc.

                                                             {

  // we explicitly set the seed, even if with a default value
  auto seed = std::default_random_engine::default_seed;

  if (argc > 1) {
    std::istringstream sstr;
    sstr.str(argv[1]);
    sstr >> seed;
    if (!sstr) {
      throw std::runtime_error
        ("Invalid seed specified: " + std::string(argv[1]));
    }
  } // if seed specified

  // this engine can be arbitrarily crappy; don't use it for real physics!
  std::default_random_engine generator(seed);
  std::cout << "Random seed: " << seed << std::endl;

  // try all these isolation radii
  std::vector<float>        const Radii { 0.05, 0.1, 0.5, 2.0 };
  std::vector<unsigned int> const DataSizes { 100, 10000 };

  for (unsigned int nPoints: DataSizes)
    PointIsolationTest(generator, nPoints, Radii);

} // PointIsolationTestCase()

template<typename Engine , typename Coord = float>

void PointIsolationTest	(	Engine &	generator,
		unsigned int	nPoints,
		std::vector< Coord > const &	radii
	)

Definition at line 57 of file PointIsolationAlgRandom_test.cc.

  {

  using Coord_t = Coord;

  //
  // create the input sample
  //
  std::uniform_real_distribution<Coord_t> uniform(-1., +1.);
  auto randomCoord = std::bind(uniform, generator);

  using Point_t = std::array<Coord_t, 3U>;
  std::vector<Point_t> points;

  points.reserve(nPoints);
  for (unsigned int i = 0; i < nPoints; ++i)
    points.push_back({{ randomCoord(), randomCoord(), randomCoord() }});
  std::cout
    << "\n" << std::string(75, '=')
    << "\nTest with " << nPoints << " points"
    << "\n" << std::string(72, '-')
    << std::endl;

  //
  // create the algorithm
  //
  using PointIsolationAlg_t = lar::example::PointIsolationAlg<Coord_t>;

  typename PointIsolationAlg_t::Configuration_t config;
  config.rangeX = { -2., +2. };
  config.rangeY = { -2., +2. };
  config.rangeZ = { -2., +2. };
  config.radius2 = 1.;
//  config.maxMemory = 100 * 1048576; // we keep the default memory setting
  PointIsolationAlg_t algo(config);

  //
  // for each isolation radius:
  //

  // measurement in milliseconds, double precision:
  testing::StopWatch<std::chrono::duration<double, std::milli>> timer;
  for (Coord_t radius: radii) {

    //
    // set up the algorithm
    //
    config.radius2 = cet::square(radius);
    algo.reconfigure(config);

    std::cout << "Isolation radius: " << radius << std::endl;

    //
    // run the algorithm with the brute force approach
    //
    timer.restart();
    auto expected
      = algo.bruteRemoveIsolatedPoints(points.begin(), points.end());
    auto elapsed = timer.elapsed();
    std::sort(expected.begin(), expected.end());
    std::cout << "  brute force: " << elapsed << " ms"
      << std::endl;

    //
    // run the algorithm with the default approach
    //
    timer.restart();
    auto actual = algo.removeIsolatedPoints(points);
    elapsed = timer.elapsed();
    std::sort(actual.begin(), actual.end());
    std::cout << "  regular:     " << elapsed << " ms"
      << std::endl;

    //
    // sort and compare the results
    //
    BOOST_TEST(actual == expected, boost::test_tools::per_element());

  } // for isolation radius

  std::cout << std::string(72, '-') << std::endl;

} // PointIsolationTest()