Cluster_test.cc File Reference

Simple test on a recob::Cluster object. More...

#include <utility>
#include "boost/test/unit_test.hpp"
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"
#include "lardataobj/RecoBase/Cluster.h"

Go to the source code of this file.

Macros
#define	BOOST_TEST_MODULE   ( cluster_test )

Functions
void	CheckCluster (recob::Cluster const &cluster, float start_wire, float sigma_start_wire, float start_tick, float sigma_start_tick, float start_charge, float start_angle, float start_opening, float end_wire, float sigma_end_wire, float end_tick, float sigma_end_tick, float end_charge, float end_angle, float end_opening, float integral, float integral_stddev, float summedADC, float summedADC_stddev, unsigned int n_hits, float multiple_hit_density, float width, recob::Cluster::ID_t ID, geo::View_t view, geo::PlaneID const &plane)
void	ClusterTestDefaultConstructor ()
void	ClusterTestCustomConstructor ()
void	ClusterTestCopyMoveOperations ()
	BOOST_AUTO_TEST_CASE (ClusterDefaultConstructor)
	BOOST_AUTO_TEST_CASE (ClusterCustomConstructors)
	BOOST_AUTO_TEST_CASE (ClusterCopyMoveOperations)

Detailed Description

Simple test on a recob::Cluster object.

Author

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

Date

20150114

Version

1.0

This test simply creates recob::Cluster objects and verifies that the values it can access are the right ones.

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

Timing: version 1.0: ~1.5" (debug mode)

Definition in file Cluster_test.cc.

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( cluster_test )

Definition at line 31 of file Cluster_test.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

ClusterDefaultConstructor

)

Definition at line 765 of file Cluster_test.cc.

                                                {
  ClusterTestDefaultConstructor();
}

BOOST_AUTO_TEST_CASE

(

ClusterCustomConstructors

)

Definition at line 769 of file Cluster_test.cc.

                                                {
  ClusterTestCustomConstructor();
}

BOOST_AUTO_TEST_CASE

(

ClusterCopyMoveOperations

)

Definition at line 773 of file Cluster_test.cc.

                                                {
  ClusterTestCopyMoveOperations();
}

void CheckCluster	(	recob::Cluster const &	cluster,
		float	start_wire,
		float	sigma_start_wire,
		float	start_tick,
		float	sigma_start_tick,
		float	start_charge,
		float	start_angle,
		float	start_opening,
		float	end_wire,
		float	sigma_end_wire,
		float	end_tick,
		float	sigma_end_tick,
		float	end_charge,
		float	end_angle,
		float	end_opening,
		float	integral,
		float	integral_stddev,
		float	summedADC,
		float	summedADC_stddev,
		unsigned int	n_hits,
		float	multiple_hit_density,
		float	width,
		recob::Cluster::ID_t	ID,
		geo::View_t	view,
		geo::PlaneID const &	plane
	)

Definition at line 45 of file Cluster_test.cc.

  {

  // verify that the values are as expected
  // - NHits
  BOOST_TEST(cluster.NHits() == n_hits);

  // - start wire
  BOOST_TEST(cluster.StartWire() == start_wire);

  // - start wire uncertainty
  BOOST_TEST(cluster.SigmaStartWire() == sigma_start_wire);

  // - start tick
  BOOST_TEST(cluster.StartTick() == start_tick);

  // - start tick uncertainty
  BOOST_TEST(cluster.SigmaStartTick() == sigma_start_tick);

  // - end wire
  BOOST_TEST(cluster.EndWire() == end_wire);

  // - end wire uncertainty
  BOOST_TEST(cluster.SigmaEndWire() == sigma_end_wire);

  // - end tick
  BOOST_TEST(cluster.EndTick() == end_tick);

  // - end tick uncertainty
  BOOST_TEST(cluster.SigmaEndTick() == sigma_end_tick);

  // - wire coordinates
  BOOST_TEST
    (cluster.WireCoord(recob::Cluster::clStart) == start_wire);
  BOOST_TEST
    (cluster.WireCoord((unsigned int) recob::Cluster::clStart) == start_wire);
  BOOST_TEST
    (cluster.WireCoord(recob::Cluster::clEnd) == end_wire);
  BOOST_TEST
    (cluster.WireCoord((unsigned int) recob::Cluster::clEnd) == end_wire);

  // - tick coordinates
  BOOST_TEST
    (cluster.TickCoord(recob::Cluster::clStart) == start_tick);
  BOOST_TEST
    (cluster.TickCoord((unsigned int) recob::Cluster::clStart) == start_tick);
  BOOST_TEST
    (cluster.TickCoord(recob::Cluster::clEnd) == end_tick);
  BOOST_TEST
    (cluster.TickCoord((unsigned int) recob::Cluster::clEnd) == end_tick);

  // - start charge
  BOOST_TEST(cluster.StartCharge() == start_charge);

  // - start angle
  BOOST_TEST(cluster.StartAngle() == start_angle);

  // - start opening angle
  BOOST_TEST(cluster.StartOpeningAngle() == start_opening);

  // - end charge
  BOOST_TEST(cluster.EndCharge() == end_charge);

  // - end angle
  BOOST_TEST(cluster.EndAngle() == end_angle);

  // - end opening angle
  BOOST_TEST(cluster.EndOpeningAngle() == end_opening);

  // - edge charge
  BOOST_TEST
    (cluster.EdgeCharge(recob::Cluster::clStart) == start_charge);
  BOOST_TEST
    (cluster.EdgeCharge((unsigned int) recob::Cluster::clStart) == start_charge);
  BOOST_TEST
    (cluster.EdgeCharge(recob::Cluster::clEnd) == end_charge);
  BOOST_TEST
    (cluster.EdgeCharge((unsigned int) recob::Cluster::clEnd) == end_charge);

  // - angle
  BOOST_TEST
    (cluster.Angle(recob::Cluster::clStart) == start_angle);
  BOOST_TEST
    (cluster.Angle((unsigned int) recob::Cluster::clStart) == start_angle);
  BOOST_TEST
    (cluster.Angle(recob::Cluster::clEnd) == end_angle);
  BOOST_TEST
    (cluster.Angle((unsigned int) recob::Cluster::clEnd) == end_angle);

  // - edge opening angle
  BOOST_TEST
    (cluster.OpeningAngle(recob::Cluster::clStart) == start_opening);
  BOOST_TEST
    (cluster.OpeningAngle((unsigned int) recob::Cluster::clStart) == start_opening);
  BOOST_TEST
    (cluster.OpeningAngle(recob::Cluster::clEnd) == end_opening);
  BOOST_TEST
    (cluster.OpeningAngle((unsigned int) recob::Cluster::clEnd) == end_opening);

  // - integral
  BOOST_TEST(cluster.Integral() == integral);

  // - integral standard deviation
  BOOST_TEST(cluster.IntegralStdDev() == integral_stddev);

  // - integral average
  const float integral_average = (n_hits != 0)? integral / n_hits: 0.;
  BOOST_TEST(cluster.IntegralAverage() == integral_average);

  // - summed ADC
  BOOST_TEST(cluster.SummedADC() == summedADC);

  // - summed ADC standard deviation
  BOOST_TEST(cluster.SummedADCstdDev() == summedADC_stddev);

  // - summed ADC average
  const float summedADC_average = (n_hits != 0)? summedADC / n_hits: 0.;
  BOOST_TEST(cluster.SummedADCaverage() == summedADC_average);

  // - charge
  BOOST_TEST(cluster.Charge(recob::Cluster::cmFit) == integral);
  BOOST_TEST
    (cluster.Charge((unsigned int) recob::Cluster::cmFit) == integral);
  BOOST_TEST
    (cluster.Charge(recob::Cluster::cmADC) == summedADC);
  BOOST_TEST
    (cluster.Charge((unsigned int) recob::Cluster::cmADC) == summedADC);

  // - charge standard deviation
  BOOST_TEST
    (cluster.ChargeStdDev(recob::Cluster::cmFit) == integral_stddev);
  BOOST_TEST
    (cluster.ChargeStdDev((unsigned int) recob::Cluster::cmFit) == integral_stddev);
  BOOST_TEST
    (cluster.ChargeStdDev(recob::Cluster::cmADC) == summedADC_stddev);
  BOOST_TEST
    (cluster.ChargeStdDev((unsigned int) recob::Cluster::cmADC) == summedADC_stddev);

  // - charge standard deviation
  BOOST_TEST
    (cluster.ChargeAverage(recob::Cluster::cmFit) == integral_average);
  BOOST_TEST
    (cluster.ChargeAverage((unsigned int) recob::Cluster::cmFit) == integral_average);
  BOOST_TEST
    (cluster.ChargeAverage(recob::Cluster::cmADC) == summedADC_average);
  BOOST_TEST
    (cluster.ChargeAverage((unsigned int) recob::Cluster::cmADC) == summedADC_average);

  // - wires over hits
  BOOST_TEST(cluster.MultipleHitDensity() == multiple_hit_density);

  // - width
  BOOST_TEST(cluster.Width() == width);

  // - ID
  BOOST_TEST(cluster.ID() == ID);

  // - view
  BOOST_TEST(cluster.View() == view);

  // - plane
  BOOST_TEST(cluster.Plane() == plane);
  BOOST_TEST(cluster.hasPlane() == plane.isValid);

} // CheckCluster()

void ClusterTestCopyMoveOperations

(

)

Definition at line 402 of file Cluster_test.cc.

                                     {

  //
  // Part I: initialization of wire inputs
  //
  const float start_wire         =   12.5;
  const float sigma_start_wire   =    1.0;
  const float start_tick         =  141.3;
  const float sigma_start_tick   =    0.2;
  const float start_charge       =   45.2;
  const float start_angle        =    1.5;
  const float start_opening      =    0.7;
  const float end_wire           =  223.4;
  const float sigma_end_wire     =    1.0;
  const float end_tick           =  563.2;
  const float sigma_end_tick     =    0.3;
  const float end_charge         =  152.1;
  const float end_angle          =    0.6;
  const float end_opening        =    0.1;
  const float integral           = 4856.7;
  const float integral_stddev    =    4.3;
  const float summedADC          = 4702.4;
  const float summedADC_stddev   =    6.2;
  const unsigned int n_hits      =  210;
  const float multiple_hit_density =    1.0;
  const float width              =   75.2;
  const recob::Cluster::ID_t ID  = 1234;
  const geo::View_t view         = geo::kV;
  const geo::PlaneID plane(0, 1, 2);

  //
  // Part II: full constructor (tested elsewhere)
  //
  const recob::Cluster cluster(
    start_wire,
    sigma_start_wire,
    start_tick,
    sigma_start_tick,
    start_charge,
    start_angle,
    start_opening,
    end_wire,
    sigma_end_wire,
    end_tick,
    sigma_end_tick,
    end_charge,
    end_angle,
    end_opening,
    integral,
    integral_stddev,
    summedADC,
    summedADC_stddev,
    n_hits,
    multiple_hit_density,
    width,
    ID,
    view,
    plane,
    recob::Cluster::Sentry
    );


  //
  // Part III: copy constructor
  //
  // step III.1: copy the cluster
  recob::Cluster cluster_copy(cluster);

  // step III.2: verify that the original cluster has not changed
  CheckCluster(cluster,
    start_wire,
    sigma_start_wire,
    start_tick,
    sigma_start_tick,
    start_charge,
    start_angle,
    start_opening,
    end_wire,
    sigma_end_wire,
    end_tick,
    sigma_end_tick,
    end_charge,
    end_angle,
    end_opening,
    integral,
    integral_stddev,
    summedADC,
    summedADC_stddev,
    n_hits,
    multiple_hit_density,
    width,
    ID,
    view,
    plane
    );

  // step III.3: verify that the copy cluster is as the original one
  CheckCluster(cluster_copy,
    start_wire,
    sigma_start_wire,
    start_tick,
    sigma_start_tick,
    start_charge,
    start_angle,
    start_opening,
    end_wire,
    sigma_end_wire,
    end_tick,
    sigma_end_tick,
    end_charge,
    end_angle,
    end_opening,
    integral,
    integral_stddev,
    summedADC,
    summedADC_stddev,
    n_hits,
    multiple_hit_density,
    width,
    ID,
    view,
    plane
    );


  //
  // Part IV: move constructor
  //
  // step IV.1: move the cluster
  recob::Cluster cluster_move(std::move(cluster_copy));

  // step IV.2: verify that the original cluster differ only by the invalid ID
  CheckCluster(cluster_copy,
    start_wire,
    sigma_start_wire,
    start_tick,
    sigma_start_tick,
    start_charge,
    start_angle,
    start_opening,
    end_wire,
    sigma_end_wire,
    end_tick,
    sigma_end_tick,
    end_charge,
    end_angle,
    end_opening,
    integral,
    integral_stddev,
    summedADC,
    summedADC_stddev,
    n_hits,
    multiple_hit_density,
    width,
    recob::Cluster::InvalidID,
    view,
    plane
    );

  // step IV.3: verify that the new cluster is as the original was
  CheckCluster(cluster_move,
    start_wire,
    sigma_start_wire,
    start_tick,
    sigma_start_tick,
    start_charge,
    start_angle,
    start_opening,
    end_wire,
    sigma_end_wire,
    end_tick,
    sigma_end_tick,
    end_charge,
    end_angle,
    end_opening,
    integral,
    integral_stddev,
    summedADC,
    summedADC_stddev,
    n_hits,
    multiple_hit_density,
    width,
    ID,
    view,
    plane
    );


  //
  // Part V: copy assignment
  //
  // step V.1: copy over the cluster
  cluster_copy = cluster;

  // step V.2: verify that the original cluster is unchanged
  CheckCluster(cluster,
    start_wire,
    sigma_start_wire,
    start_tick,
    sigma_start_tick,
    start_charge,
    start_angle,
    start_opening,
    end_wire,
    sigma_end_wire,
    end_tick,
    sigma_end_tick,
    end_charge,
    end_angle,
    end_opening,
    integral,
    integral_stddev,
    summedADC,
    summedADC_stddev,
    n_hits,
    multiple_hit_density,
    width,
    ID,
    view,
    plane
    );

  // step V.3: verify that the new cluster is as the original
  CheckCluster(cluster_copy,
    start_wire,
    sigma_start_wire,
    start_tick,
    sigma_start_tick,
    start_charge,
    start_angle,
    start_opening,
    end_wire,
    sigma_end_wire,
    end_tick,
    sigma_end_tick,
    end_charge,
    end_angle,
    end_opening,
    integral,
    integral_stddev,
    summedADC,
    summedADC_stddev,
    n_hits,
    multiple_hit_density,
    width,
    ID,
    view,
    plane
    );


  //
  // Part VI: move assignment (regular)
  //
  // step VI.1: move the cluster
  cluster_move = std::move(cluster_copy);

  // step IV.2: verify that the original cluster differ only by the invalid ID
  CheckCluster(cluster_copy,
    start_wire,
    sigma_start_wire,
    start_tick,
    sigma_start_tick,
    start_charge,
    start_angle,
    start_opening,
    end_wire,
    sigma_end_wire,
    end_tick,
    sigma_end_tick,
    end_charge,
    end_angle,
    end_opening,
    integral,
    integral_stddev,
    summedADC,
    summedADC_stddev,
    n_hits,
    multiple_hit_density,
    width,
    recob::Cluster::InvalidID,
    view,
    plane
    );

  // step VI.3: verify that the new cluster is as the original was
  CheckCluster(cluster_move,
    start_wire,
    sigma_start_wire,
    start_tick,
    sigma_start_tick,
    start_charge,
    start_angle,
    start_opening,
    end_wire,
    sigma_end_wire,
    end_tick,
    sigma_end_tick,
    end_charge,
    end_angle,
    end_opening,
    integral,
    integral_stddev,
    summedADC,
    summedADC_stddev,
    n_hits,
    multiple_hit_density,
    width,
    ID,
    view,
    plane
    );

  //
  // Part VII: move assignment (self)
  //
  // step VII.1: move the cluster into itself
  // for c2: redundant and illegal => not testing it any more
  /*
  cluster_move = std::move(cluster_move);

  // step VII.3: verify that the cluster is unchanged
  CheckCluster(cluster_move,
    start_wire,
    sigma_start_wire,
    start_tick,
    sigma_start_tick,
    start_charge,
    start_angle,
    start_opening,
    end_wire,
    sigma_end_wire,
    end_tick,
    sigma_end_tick,
    end_charge,
    end_angle,
    end_opening,
    integral,
    integral_stddev,
    summedADC,
    summedADC_stddev,
    n_hits,
    multiple_hit_density,
    width,
    ID,
    view,
    plane
    );
  */

} // ClusterTestCopyMoveOperations()

void ClusterTestCustomConstructor

(

)

Definition at line 306 of file Cluster_test.cc.

                                    {

  //
  // Part I: initialization of cluster inputs
  //
  const float start_wire         =   12.5;
  const float sigma_start_wire   =    1.0;
  const float start_tick         =  141.3;
  const float sigma_start_tick   =    0.2;
  const float start_charge       =   45.2;
  const float start_angle        =    1.5;
  const float start_opening      =    0.7;
  const float end_wire           =  223.4;
  const float sigma_end_wire     =    1.0;
  const float end_tick           =  563.2;
  const float sigma_end_tick     =    0.3;
  const float end_charge         =  152.1;
  const float end_angle          =    0.6;
  const float end_opening        =    0.1;
  const float integral           = 4856.7;
  const float integral_stddev    =    4.3;
  const float summedADC          = 4702.4;
  const float summedADC_stddev   =    6.2;
  const unsigned int n_hits      =  210;
  const float multiple_hit_density =    1.0;
  const float width              =   75.2;
  const recob::Cluster::ID_t ID  = 1234;
  const geo::View_t view         = geo::kV;
  const geo::PlaneID plane(0, 1, 2);

  //
  // Part II: constructor
  //
  // step II.1: create a cluster
  recob::Cluster cluster(
    start_wire,
    sigma_start_wire,
    start_tick,
    sigma_start_tick,
    start_charge,
    start_angle,
    start_opening,
    end_wire,
    sigma_end_wire,
    end_tick,
    sigma_end_tick,
    end_charge,
    end_angle,
    end_opening,
    integral,
    integral_stddev,
    summedADC,
    summedADC_stddev,
    n_hits,
    multiple_hit_density,
    width,
    ID,
    view,
    plane,
    recob::Cluster::Sentry
    );


  // step II.2: verify that the values are as expected
  CheckCluster(cluster,
    start_wire,
    sigma_start_wire,
    start_tick,
    sigma_start_tick,
    start_charge,
    start_angle,
    start_opening,
    end_wire,
    sigma_end_wire,
    end_tick,
    sigma_end_tick,
    end_charge,
    end_angle,
    end_opening,
    integral,
    integral_stddev,
    summedADC,
    summedADC_stddev,
    n_hits,
    multiple_hit_density,
    width,
    ID,
    view,
    plane
    );


} // ClusterTestCustomConstructor()

void ClusterTestDefaultConstructor

(

)

Definition at line 237 of file Cluster_test.cc.

                                     {

  //
  // Part I: initialization of cluster inputs
  //
  // these are the values expected for a default-constructed cluster
  const float start_wire         =    0.0;
  const float sigma_start_wire   =    0.0;
  const float start_tick         =    0.0;
  const float sigma_start_tick   =    0.0;
  const float start_charge       =    0.0;
  const float start_angle        =    0.0;
  const float start_opening      =    0.0;
  const float end_wire           =    0.0;
  const float sigma_end_wire     =    0.0;
  const float end_tick           =    0.0;
  const float sigma_end_tick     =    0.0;
  const float end_charge         =    0.0;
  const float end_angle          =    0.0;
  const float end_opening        =    0.0;
  const float integral           =    0.0;
  const float integral_stddev    =    0.0;
  const float summedADC          =    0.0;
  const float summedADC_stddev   =    0.0;
  const unsigned int n_hits      =    0;
  const float multiple_hit_density =    0.0;
  const float width              =    0.0;
  const recob::Cluster::ID_t ID  = recob::Cluster::InvalidID;
  const geo::View_t view         = geo::kUnknown;
  const geo::PlaneID plane;

  //
  // Part II: default constructor
  //
  // step II.1: create a cluster with default constructor
  recob::Cluster cluster;


  // step II.2: verify that the values are as expected
  CheckCluster(cluster,
    start_wire,
    sigma_start_wire,
    start_tick,
    sigma_start_tick,
    start_charge,
    start_angle,
    start_opening,
    end_wire,
    sigma_end_wire,
    end_tick,
    sigma_end_tick,
    end_charge,
    end_angle,
    end_opening,
    integral,
    integral_stddev,
    summedADC,
    summedADC_stddev,
    n_hits,
    multiple_hit_density,
    width,
    ID,
    view,
    plane
    );

} // WireTestDefaultConstructor()