raw_test.cc File Reference

Tests the raw data compression routines. More...

#include <cmath>
#include <limits>
#include <random>
#include <string>
#include <map>
#include <iostream>
#include "boost/test/unit_test.hpp"
#include "larcoreobj/SimpleTypesAndConstants/PhysicalConstants.h"
#include "larcoreobj/SimpleTypesAndConstants/RawTypes.h"
#include "lardataobj/RawData/raw.h"

Go to the source code of this file.

Classes
class	DataCreatorBase
	Interface of an object creating data to be tested on. More...
class	UniformNoiseCreator
	Data creator: uniformly random data, specified range plus offset (pedestal) More...
class	GaussianNoiseCreator
	Data creator: Gaussian random data. More...
class	SineWaveCreator
	Data creator: sine wave data. More...
class	RandomDataCreator
	Data creator: uniformly random data, full range. More...

Macros
#define	BOOST_TEST_MODULE   ( raw_test )

Functions
void	RunDataCompressionTest (std::string id, const std::vector< short > &data, raw::Compress_t mode)
	Tests a data set with a given compression. More...
void	RunDataCompressionTests (DataCreatorBase *pDataCreator)
	Runs data compression tests with selected compression modes. More...
	BOOST_AUTO_TEST_CASE (NullData)
	BOOST_AUTO_TEST_CASE (ConstantData)
	BOOST_AUTO_TEST_CASE (SmallUniformNoiseData)
	BOOST_AUTO_TEST_CASE (SmallUniformNoiseOffsetData)
	BOOST_AUTO_TEST_CASE (LargeUniformNoiseData)
	BOOST_AUTO_TEST_CASE (SmallGaussianNoiseOffsetData)
	BOOST_AUTO_TEST_CASE (LargeGaussianNoiseData)
	BOOST_AUTO_TEST_CASE (VeryLowFrequencySineWaveData)
	BOOST_AUTO_TEST_CASE (LowFrequencySineWaveData)
	BOOST_AUTO_TEST_CASE (HighFrequencySineWaveData)

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

Detailed Description

Tests the raw data compression routines.

Author

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

Date

20140716

Version

1.0

This test covers only no compression and Huffman compression. If compresses a data set, uncompresses it back and checks that the result is the same as the original one. As such, it does not support lossy compression (like zero suppression).

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

Timing: version 1.0 takes less than 3" on a 3 GHz machine

Definition in file raw_test.cc.

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( raw_test )

Definition at line 37 of file raw_test.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

NullData

)

Definition at line 291 of file raw_test.cc.

                               {
        UniformNoiseCreator InputData("null input data", 0.);
        RunDataCompressionTests(&InputData);
}

BOOST_AUTO_TEST_CASE

(

ConstantData

)

Definition at line 296 of file raw_test.cc.

                                   {
        UniformNoiseCreator InputData("constant input data", 0., 41.);
        RunDataCompressionTests(&InputData);
}

BOOST_AUTO_TEST_CASE

(

SmallUniformNoiseData

)

Definition at line 301 of file raw_test.cc.

                                            {
        UniformNoiseCreator InputData("uniform small noise", 5.);
        RunDataCompressionTests(&InputData);
}

BOOST_AUTO_TEST_CASE

(

SmallUniformNoiseOffsetData

)

Definition at line 306 of file raw_test.cc.

                                                  {
        UniformNoiseCreator InputData("uniform small noise and offset", 5., 123.2);
        RunDataCompressionTests(&InputData);
}

BOOST_AUTO_TEST_CASE

(

LargeUniformNoiseData

)

Definition at line 311 of file raw_test.cc.

                                            {
        UniformNoiseCreator InputData("uniform large noise", 40.);
        RunDataCompressionTests(&InputData);
}

BOOST_AUTO_TEST_CASE

(

SmallGaussianNoiseOffsetData

)

Definition at line 316 of file raw_test.cc.

                                                   {
        GaussianNoiseCreator InputData("Gaussian small noise and offset", 5., 123.2);
        RunDataCompressionTests(&InputData);
}

BOOST_AUTO_TEST_CASE

(

LargeGaussianNoiseData

)

Definition at line 321 of file raw_test.cc.

                                             {
        GaussianNoiseCreator InputData("Gaussian large noise and offset", 40., 194.);
        RunDataCompressionTests(&InputData);
}

BOOST_AUTO_TEST_CASE

(

VeryLowFrequencySineWaveData

)

Definition at line 326 of file raw_test.cc.

                                                   {
        SineWaveCreator InputData("Very low frequency pure sine wave", 1024., 50.);
        RunDataCompressionTests(&InputData);
}

BOOST_AUTO_TEST_CASE

(

LowFrequencySineWaveData

)

Definition at line 331 of file raw_test.cc.

                                               {
        SineWaveCreator InputData("Low frequency pure sine wave", 128., 100.);
        RunDataCompressionTests(&InputData);
}

BOOST_AUTO_TEST_CASE

(

HighFrequencySineWaveData

)

Definition at line 336 of file raw_test.cc.

                                                {
        SineWaveCreator InputData("High frequency pure sine wave", 16., 100.);
        RunDataCompressionTests(&InputData);
}

void RunDataCompressionTest	(	std::string	id,
		const std::vector< short > &	data,
		raw::Compress_t	mode
	)

Tests a data set with a given compression.

Parameters

id	string representing the test (short descriptive text)
data	data set (a vector of short integers)
mode	compression mode to be tested

See Also

RunDataCompressionTests

The test consists in compressing and uncompressing back data. The test fails if the uncompressed data does not match the original one.

This is actually a single step of the full test implemented in RunDataCompressionTests.

Definition at line 214 of file raw_test.cc.

{
        // working a copy of the original data:
        std::vector<short> buffer(data);

        // compress
        raw::Compress(buffer, mode);
        std::cout << id << ": compressed data size: " << buffer.size() << std::endl;

        // decompress (on an already allocated buffer)
        std::vector<short> data_again(data.size());
        raw::Uncompress(buffer, data_again, mode);

        // Boost provides facilities to compare data and print if it does not match:
        BOOST_TEST(data_again.size() == data.size());

        BOOST_CHECK_EQUAL_COLLECTIONS
          (data.begin(), data.end(), data_again.begin(), data_again.end());

} // RunDataCompressionTest()

void RunDataCompressionTests

(

DataCreatorBase *

pDataCreator

)

Runs data compression tests with selected compression modes.

Parameters

pDataCreator

an object to create the input data set

See Also

RunDataCompressionTest()

This function hard-codes some sets of parameters for the tests: the same test in RunDataCompressionTest() is repeated with different data size and different compression modes. This comprises the full test.

Definition at line 246 of file raw_test.cc.

                                                            {

        // the compression modes we are going to use, with a human-readable label
        std::map<raw::Compress_t, std::string> CompressionModes;
        CompressionModes[raw::kNone] = "uncompressed";
        CompressionModes[raw::kHuffman] = "Huffman";
//      CompressionModes[raw::kZeroSuppression] = "zero suppression";
//      CompressionModes[raw::kZeroHuffman] = "zero suppression plus Huffman";
//      CompressionModes[raw::kDynamicDec] = "dynamic";

        // the data sizes we are going to try, with a human-confusing label
        std::map<size_t, std::string> DataSizes;
        DataSizes[64] = "small size";
        DataSizes[9600] = "medium size";
        DataSizes[1048576] = "large size";

        for (const auto size_info: DataSizes) {
                // create the original data:
                const std::vector<short> data(pDataCreator->create(size_info.first));

                // test the same data with different compression algorithms:
                for (const auto test_info: CompressionModes) {
                        // a "nice" label to make output vaguely meaningful...
                        std::string test_id = pDataCreator->name()
                                + " (" + size_info.second + " " + test_info.second + ")";

                        // ... and run the test
                        RunDataCompressionTest(test_id, data, test_info.first);
                } // for compression modes
        } // for data sizes

        // that's it; Boost keeps records of successes and failures
} // RunDataCompressionTests()

Variable Documentation

constexpr unsigned int RandomSeed = 12345

The seed for the default random engine.

Definition at line 47 of file raw_test.cc.