CountersMap_test.cc File Reference

Tests the counter map. More...

#include <map>
#include <random>
#include <iostream>
#include "boost/test/unit_test.hpp"
#include "lardata/Utilities/CountersMap.h"

Go to the source code of this file.

Macros
#define	BOOST_TEST_MODULE   ( CountersMap_test )

Functions
void	RunHoughTransformTreeTest ()
	Tests with a vector of counter maps (Hough transfort use case) More...
	BOOST_AUTO_TEST_CASE (RunHoughTransformTree)

Variables
constexpr unsigned int	RandomSeed = 12345
	The seed for the default random engine. More...

Detailed Description

Tests the counter map.

Author

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

Date

20140822

Version

1.0

See http://www.boost.org/libs/test for the Boost test library home page.

Timing: version 1.0 takes about 30" on a 3 GHz machine.

Definition in file CountersMap_test.cc.

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( CountersMap_test )

Definition at line 29 of file CountersMap_test.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

RunHoughTransformTree

)

Definition at line 187 of file CountersMap_test.cc.

                                            {
  RunHoughTransformTreeTest();
  std::cout << "Done." << std::endl;
}

void RunHoughTransformTreeTest

(

)

Tests with a vector of counter maps (Hough transfort use case)

The test consists in filling a lot of points into a 2D sparse "image" (or histogram). Two structures are maintained, one with the standard STL map, another with the CountersMap. The test fails if the two images do not match.

Definition at line 53 of file CountersMap_test.cc.

                                 {

  // the structure we are testing is a 2D "image" of integers;
  // image is mostly empty (zero), but each abscissa has roughly the same
  // number of non-empty pixels (NPoints), and at least one of them.

  constexpr unsigned int NPoints =  1000;
  constexpr unsigned int NAngles = 10800;
  constexpr unsigned int NDist   =  2500; // half distance

  typedef std::map<int, int> BaseMap_t;

  // STL container
  typedef std::vector<BaseMap_t> MapVectorI_t;
  MapVectorI_t stl_image(NAngles);

  // CountersMap; uses chunks of 8 counters per block
  std::vector<lar::CountersMap<int, int, 8>> cm_image(NAngles);
  // the following should fail compilation
//  std::vector<lar::CountersMap<int, int, 9>> cm_image_broken(NAngles);

  static std::default_random_engine random_engine(RandomSeed);
  std::uniform_real_distribution<float> uniform(-1., 1.);

  for (unsigned int iPoint = 0; iPoint != NPoints; ++iPoint) {
    // we add here some simple image, not to strain the test;
    // this is a straight line
    const float offset = uniform(random_engine) * NDist;
    const float slope = uniform(random_engine);
    float d = offset;
    for (size_t iAngle = 0; iAngle < NAngles; ++iAngle) {
      // add one entry on the (angle ; distance) plane
      ++(stl_image[iAngle][int(d)]);
      cm_image[iAngle].increment(int(d)); // different interface than usual map
      // prepare for the next point; wrap in the [-NDist, NDist[ range
      d += slope;
      while (d >= (float) NDist) d -= 2*NDist;
      while (d < 0) d += 2*NDist;
    } // for iAngle
  } // for iPoint

  std::cout << "Filling complete, now checking." << std::endl;

  // we have to provide a comparison between two "different" structures
  // (having different allocators is enough to make them unrelated)
  unsigned int nExtraKeys = 0, nMismatchValue = 0, nMissingKeys = 0;
  auto stl_begin = stl_image.cbegin();
  unsigned int iMap = 0;
  for (const auto& cm_map: cm_image) {

    const MapVectorI_t::value_type& stl_map = *(stl_begin++);

    std::cout << "Map #" << iMap << " (" << cm_map.n_counters()
      << " counters, " << stl_map.size() << " real)"
      << std::endl;

    // compare the two maps; the CountersMap one has more elements,
    // since the counters are allocated in blocks;
    // if a key is in STL map, it must be also in the CountersMap;
    // if a key is not in STL map, counter in CountersMap must be missing or 0
    MapVectorI_t::value_type::const_iterator stl_iter = stl_map.begin(),
      stl_end = stl_map.end();
    for (auto p: cm_map) { // this should be a pair (index, counter)

      if (stl_iter != stl_end) { // we have still counters to find
        // if counter is already beyond the next non-empty one froml STL map,
        // then we are missing some
        while (p.first > stl_iter->first) {
          ++nMissingKeys;
          std::cout << "ERROR missing key " << stl_iter->first << std::endl;
          if (++stl_iter == stl_end) break;
        }
      } // if

      if (stl_iter != stl_end) { // we have still counters to find
        if (p.first == stl_iter->first) {
          // if the counter is in SLT map, the two counts must match
        //  std::cout << "  " << p.first << " " << p.second << std::endl;
          if (stl_iter->second != p.second) {
            std::cout << "ERROR wrong counter value " << p.second
              << ", expected " << stl_iter->second << std::endl;
            ++nMismatchValue;
          }
          ++stl_iter; // done with it
        }
        else if (p.first < stl_iter->first) {
          // if the counter is not in STL map, then it must be 0
          if (p.second != 0) {
            ++nExtraKeys;
            std::cout << "ERROR extra key " << p.first << " (" << p.second << ")"
              << std::endl;
          }
        //  else {
        //    std::cout << "  " << p.first << " " << p.second << " (not in STL)"
        //      << std::endl;
        //  }
        }
      }
      else {
        // no more keys in STL map
        if (p.second != 0) {
          ++nExtraKeys;
          std::cout << "ERROR extra key " << p.first << " (" << p.second << ")"
            << std::endl;
        }
      }
    } // for element in map

    BOOST_TEST(cm_map.is_equal(stl_map));

    // if they were the same, make sure that now they differ
    const_cast<MapVectorI_t::value_type&>(stl_map)[NDist / 2]++;
    BOOST_TEST(!cm_map.is_equal(stl_map));

    ++iMap;
  } // for map

  BOOST_TEST(nMismatchValue == 0U);
  BOOST_TEST(nMissingKeys == 0U);
  BOOST_TEST(nExtraKeys == 0U);


} // RunHoughTransformTreeTest()

Variable Documentation

constexpr unsigned int RandomSeed = 12345

The seed for the default random engine.

Definition at line 37 of file CountersMap_test.cc.