lar::example::tests Namespace Reference

Tests for LArSoft examples. More...

Classes
class	CheckDataProductSize
	Checks the size of the specified collection. More...
class	SpacePointMaker
	Creates a collection of space points. More...
class	DumpCheatTracks
	Dumps lar::example::CheatTrack data product and associations. More...
class	ParticleMaker
	Creates a collection of simulated particles. More...
class	AtomicNumberTest
	Tests AtomicNumberService. More...
class	ShowerCalibrationGaloreTest
	Tests ShowerCalibrationGaloreService. More...

Functions
int	CreateTestShowerCalibrationFromPID (std::string outputPath)
	Creates a test calibration file for ShowerCalibrationGaloreFromPID. More...
std::string	centerString (std::string const &s, unsigned int width, char pad= ' ')
	Returns a string padding s to be centered in a width w. More...
recob::Shower	MakeShower (float E, int bestPlane=2, int ID=1)
template<typename Stream >
unsigned int	ShowerCalibrationTableTest (Stream &&out, lar::example::ShowerCalibrationGalore const *calibration, float Emin=0.0, float Emax=2.5, float Estep=0.1, std::vector< lar::example::ShowerCalibrationGalore::PDGID_t > const &pids={11, 13, 111, 2212, 22})
	Synthetic test: prints corrections for showers in a energy range. More...
recob::SpacePoint	MakeSpacePoint (int ID, double const *pos, double error=0.)
	Creates and returns a new space point. More...
unsigned int	FillSpacePointGrid (std::vector< recob::SpacePoint > &spacePoints, geo::BoxBoundedGeo const &box, double stepSize)
	Creates space points distributed in a grid. More...

Detailed Description

Tests for LArSoft examples.

Function Documentation

std::string lar::example::tests::centerString ( std::string const &  s, unsigned int  width, char  pad = ' '  )

inline

Returns a string padding s to be centered in a width w.

Definition at line 34 of file ShowerCalibrationGaloreTests.h.

{
   unsigned int const left
     = std::max(0U, (width - (unsigned int) s.length()) / 2);
   unsigned int const right
     = std::max(0U, width - left - (unsigned int) s.length());
   return std::string(left, pad) + s + std::string(right, pad);
} // centerString()

int lar::example::tests::CreateTestShowerCalibrationFromPID

(

std::string

outputPath

)

Creates a test calibration file for ShowerCalibrationGaloreFromPID.

Parameters

outputPath

UNIX + ROOT path for the output ROOT directory

Returns

an error code, 0 on success

outputPath is a full ROOT directory path made of a UNIX path and a ROOT directory path. For example, "data/calibrations.root:Showers/ByType" will create a directory data and a calibrations.root ROOT file in it (or update it if exists), create a structure of two nested ROOT directories, Showers/ByType, and write all the calibration graphs in there.

It currently writes:

• "Pi0" (TGraphErrors): neutral pion calibration vs. reconstructed energy, [ 0; 2 ] GeV range
• "Photon" (TGraphErrors): photon calibration vs. reconstructed energy, [ 0; 2 ] GeV range
• "Electron" (TGraphErrors): electron/positron calibration vs. reconstructed energy, [ 0; 2 ] GeV range
• "Muon" (TGraphErrors): muon/antimuon calibration vs. reconstructed energy, [ 0; 2 ] GeV range
• "Default" (TGraphErrors): other particle calibration vs. reconstructed energy, [ 0; 5 ] GeV range

Definition at line 328 of file CreateTestShowerCalibrationFromPID.cxx.

{

   //
   // create output file
   //
   TDirectory* pOutputDir = CreateROOTdir(outputPath);
   if (!pOutputDir) {
      std::cerr << "Can't create ROOT directory '" << outputPath << "'"
         << std::endl;
      return 1;
   }
   TFile* pOutputFile = pOutputDir->GetFile();

   //
   // create the calibration histograms
   //
   pOutputDir->cd();
   try {
      WriteCalibrationObject
        (CreateNeutralPionCalibration(), "pion calibration");
      WriteCalibrationObject(CreatePhotonCalibration(), "photon calibration");
      WriteCalibrationObject
        (CreateElectronCalibration(), "electron calibration");
      WriteCalibrationObject(CreateMuonCalibration(), "muon calibration");
      WriteCalibrationObject(CreateGeneralCalibration(), "generic calibration");
   }
   catch (std::runtime_error const& e) {
      std::cerr << "An error occurred: " << e.what() << std::endl;
      return 1;
   }

   //
   // close output and leave (deliberately ONLY if writing above was successful)
   //
   pOutputDir->Write();
   pOutputFile->Write();
   delete pOutputFile;

   return 0;
} // lar::example::tests::CreateTestShowerCalibrationFromPID()

unsigned int lar::example::tests::FillSpacePointGrid	(	std::vector< recob::SpacePoint > &	spacePoints,
		geo::BoxBoundedGeo const &	box,
		double	stepSize
	)

Creates space points distributed in a grid.

Parameters

spacePoints	the container to be filled
box	the extend of volume to be filled
stepSize	the spacing between points

Returns

the number of space points added

The function adds space points to the specified collection. The centre of the box hosts a space point. The other space points are added shifting by multiples of stepSize in all directions. The IDs are incremental, starting from the ID next to the one from the last space point in the collection, or 1 if the collection is empty.

Points have an uncertainty of , with the step size.

Definition at line 40 of file SpacePointTestUtils.cxx.

  {

  // determine the starting point
  auto const indicesX = ComputeRangeIndices(box.MinX(), box.MaxX(), stepSize);
  auto const indicesY = ComputeRangeIndices(box.MinY(), box.MaxY(), stepSize);
  auto const indicesZ = ComputeRangeIndices(box.MinZ(), box.MaxZ(), stepSize);

  int ID = spacePoints.empty()? 1: spacePoints.back().ID() + 1;
  size_t const origNPoints = spacePoints.size();
  double const error = stepSize / std::sqrt(12.);

  // fill the grid;
  // we don't use an increment (point[0] += stepping) to avoid rounding errors
  std::array<double, 3> const center
    {{ box.CenterX(), box.CenterY(), box.CenterZ() }};
  std::array<double, 3> point;
  for (int ix = indicesX.first; ix <= indicesX.second; ++ix) {
    point[0] = center[0] + ix * stepSize;

    for (int iy = indicesY.first; iy <= indicesY.second; ++iy) {
      point[1] = center[1] + iy * stepSize;

      for (int iz = indicesZ.first; iz <= indicesZ.second; ++iz) {
        point[2] = center[2] + iz * stepSize;

        spacePoints.push_back(MakeSpacePoint(ID++, point.data(), error));

      } // for z
    } // for y
  } // for x

  return spacePoints.size() - origNPoints;
} // lar::example::tests::FillSpacePointGrid()

recob::Shower lar::example::tests::MakeShower ( float  E, int  bestPlane = 2, int  ID = 1  )

inline

Definition at line 47 of file ShowerCalibrationGaloreTests.h.

                                                                      {
   // a shower on a 3-plane detector
   return recob::Shower(
      {    0.,   0.,   1. }, // direction (cosines) at vertex: along z axis
      { 1e-3, 1e-3, 1e-3  }, // uncertainty on the above
      {    0.,   0.,   0. }, // start vertex (somewhere; we don't use geometry)
      { 1e-3, 1e-3, 1e-3  }, // uncertainty on the above
      {    1.,   1.,   1. }, // consistent measurement of 1 (GeV?) on all planes
      { 1e-1, 1e-1, 1e-1  }, // uncertainty on the above (10%)
      {    E,    E,    E  }, // consistent measurement of 1 (GeV?) on all planes
      { 0.1*E, 0.1*E, 0.1*E }, // uncertainty on the above (10%)
      bestPlane,             // elect the last as the best plane
      ID                     // ID
     );
} // MakeShower()

recob::SpacePoint lar::example::tests::MakeSpacePoint	(	int	ID,
		double const *	pos,
		double	error = 0.
	)

Creates and returns a new space point.

Parameters

ID	space point identifier
pos	space point position: { x, y, z } [cm]
error	uncertainty on position (applies to all the coordinates)

Returns

a new space point

Points are uncorrelated.

Definition at line 26 of file SpacePointTestUtils.cxx.

{
  // assume it's upper triangular; the documentation does not say
  double const err[6] = { error, 0., 0., error, 0., error };
  return {
    pos,
    err,
    0.0, // chisq
    ID
    };
} // lar::example::tests::MakeSpacePoint()

template<typename Stream >

unsigned int lar::example::tests::ShowerCalibrationTableTest	(	Stream &&	out,
		lar::example::ShowerCalibrationGalore const *	calibration,
		float	Emin = 0.0,
		float	Emax = 2.5,
		float	Estep = 0.1,
		std::vector< lar::example::ShowerCalibrationGalore::PDGID_t > const &	pids = { 11, 13, 111, 2212, 22 }
	)

Synthetic test: prints corrections for showers in a energy range.

Template Parameters

Stream

type of output stream

Parameters

out	output stream
calibration	service provider
Emin	lower shower energy for the printout [GeV] (default: 0)
Emax	upper shower energy for the printout GeV
Estep	energy step size for the printout [GeV] (default: have 10 steps)
pids	use these PIDs (default: { 11, 13, 111, 2212, 22 })

Returns

number of detected errors (currently always 0)

The corrections are printed in a table like:

E [GeV]      particle1        particle2      ...
 0.000    1.000 +/- 0.000  1.023 +/- 0.003   ...
 ...

Definition at line 83 of file ShowerCalibrationGaloreTests.h.

       { 11, 13, 111, 2212, 22 }
) {

   // a shower with 2 GeV of energy
   recob::Shower shower = MakeShower(2.);

   using PIDInfo_t
     = std::pair<lar::example::ShowerCalibrationGalore::PDGID_t, std::string>;
   std::vector<PIDInfo_t> const KnownPIDs = {
      {   11, "e-" },
      {   13, "mu-" },
      {  -11, "e+" },
      {  -13, "mu+" },
      {  211, "pi+" },
      {  111, "pi0" },
      { 2112, "n" },
      { 2212, "p" },
      {   22, "photon" },
      {    0, "default" }
   };
   PIDInfo_t const UnknownPID = { 0, "<unnamed>" };

   // compute a default Estep to have 10 steps
   if (Estep == 0.) Estep = std::abs(Emax - Emin) / 10;
   if (Emax < Emin) Estep = -std::abs(Estep);
   const unsigned int nSteps
     = (Emax == Emin)? 1U: (unsigned int)((Emax - Emin)/Estep);

   constexpr unsigned int widthE      = 7;
   constexpr unsigned int widthF      = 5;
   constexpr unsigned int widthFtoErr = 5;
   constexpr unsigned int widthFerr   = 5;
   constexpr unsigned int widthCorr   = widthF + widthFtoErr + widthFerr;
   const std::string sep = "  ";

   // table header
   out << centerString("E [GeV]", widthE);
   for (auto pid: pids) {
      auto iKnown = std::find_if(KnownPIDs.begin(), KnownPIDs.end(),
        [pid](PIDInfo_t const& info){ return pid == std::get<0>(info); }
        );
      out << sep;
      if (iKnown == KnownPIDs.end()) {
         out << std::setw(widthF) << "PID="
             << std::left << std::setw(widthFtoErr + widthFerr) << pid
             << std::right;
      }
      else {
         out << centerString(std::get<1>(*iKnown), widthCorr);
      }
   } // for

   // print a line of corrections for each energy
   for (unsigned int i = 0; i <= nSteps; ++i) {

      float const E = Emin + i * Estep;

      // set the same energy from every of the three planes
      shower.set_total_energy({ E, E, E });

      out << "\n"
        << std::fixed << std::setw(widthE) << std::setprecision(3) << E;

      for (auto pid: pids) {
         auto corr = calibration->correction(shower, pid);

         out << sep
           << std::fixed << std::setw(widthF) << corr.factor
           << std::setw(widthFtoErr) << " +/- "
           << std::fixed << std::setw(widthFerr) << corr.error;

      } // for (pid)

   } // for (i)
   out << "\n";

   return 0; // no real error detection here, sorry
} // ShowerCalibrationTest()