DetectorPropertiesStandard_test.cc File Reference

Simple instantiation-only test for DetectorPropertiesStandard. More...

#include "larcorealg/CoreUtils/RealComparisons.h"
#include "larcorealg/Geometry/ChannelMapStandardAlg.h"
#include "larcorealg/Geometry/GeometryCore.h"
#include "lardataalg/DetectorInfo/DetectorClocksStandardTestHelpers.h"
#include "lardataalg/DetectorInfo/DetectorPropertiesStandard.h"
#include "lardataalg/DetectorInfo/DetectorPropertiesStandardTestHelpers.h"
#include "lardataalg/DetectorInfo/LArPropertiesStandardTestHelpers.h"
#include "test/Geometry/geometry_unit_test_base.h"
#include <array>
#include <iomanip>

Go to the source code of this file.

Typedefs
using	TesterConfiguration = testing::BasicGeometryEnvironmentConfiguration< geo::ChannelMapStandardAlg >
using	TestEnvironment = testing::GeometryTesterEnvironment< TesterConfiguration >

Functions
int	main (int argc, char const **argv)
	Runs the test. More...

Detailed Description

Simple instantiation-only test for DetectorPropertiesStandard.

Author

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

Date

May 6th, 2016

Definition in file DetectorPropertiesStandard_test.cc.

Typedef Documentation

using TestEnvironment = testing::GeometryTesterEnvironment<TesterConfiguration>

Definition at line 34 of file DetectorPropertiesStandard_test.cc.

using TesterConfiguration = testing::BasicGeometryEnvironmentConfiguration<geo::ChannelMapStandardAlg>

Definition at line 33 of file DetectorPropertiesStandard_test.cc.

Function Documentation

int main	(	int	argc,
		char const **	argv
	)

Runs the test.

---

Parameters

argc	number of arguments in argv
argv	arguments to the function

Returns

number of detected errors (0 on success)

Exceptions

cet::exception

most of error situations throw

The arguments in argv are: 0. name of the executable ("DetectorPropertiesStandard_test")

1. (mandatory) path to the FHiCL configuration file
2. FHiCL path to the configuration of the test (default: physics.analyzers.larptest)
3. FHiCL path to the configuration of DetectorProperties service (default: services.DetectorPropertiesService)

Definition at line 58 of file DetectorPropertiesStandard_test.cc.

{

  TesterConfiguration config("detp_test");

  //
  // parameter parsing
  //
  int iParam = 0;

  // first argument: configuration file (mandatory)
  if (++iParam < argc)
    config.SetConfigurationPath(argv[iParam]);
  else {
    std::cerr << "FHiCL configuration file path required as first argument!" << std::endl;
    return 1;
  }

  // second argument: path of the parameter set for geometry test configuration
  // (optional; default does not have any tester)
  if (++iParam < argc) config.SetMainTesterParameterSetPath(argv[iParam]);

  // third argument: path of the parameter set for DetectorProperties confi
  // (optional; default: "services.DetectorProperties" from inherited object)
  if (++iParam < argc) {
    config.SetServiceParameterSetPath("DetectorPropertiesService", argv[iParam]);
  }

  unsigned int nErrors = 0 /* Tester.Run() */;

  //
  // testing environment setup
  //
  TestEnvironment TestEnv(config);

  // DetectorPropertiesStandard and all its dependencies support the simple set
  // up (see testing::TesterEnvironment::SimpleProviderSetup()), except for
  // Geometry, that has been configured already in the geometry-aware
  // environment. So we invoke a simple set up for each of the dependencies:
  TestEnv.SimpleProviderSetup<detinfo::LArPropertiesStandard>();
  TestEnv.SimpleProviderSetup<detinfo::DetectorClocksStandard>();
  TestEnv.SimpleProviderSetup<detinfo::DetectorPropertiesStandard>();

  //
  // run the test algorithm
  // (I leave it here for reference -- there is no test algorithm here)
  //

  // 1. we initialize it from the configuration in the environment,
  //  MyTestAlgo Tester(TestEnv.TesterParameters());

  // 2. we set it up with the geometry from the environment
  //  Tester.Setup(*(TestEnv.Provider<detinfo::DetectorProperties>()));

  // 3. then we run it!
  auto const& geom = *TestEnv.Provider<geo::GeometryCore>();
  auto const clock_data = TestEnv.Provider<detinfo::DetectorClocks>()->DataForJob();
  auto const& detp = *TestEnv.Provider<detinfo::DetectorProperties>();

  auto const driftVelocity = detp.DriftVelocity();
  auto const TDCtick = sampling_rate(clock_data);
  unsigned int const nWaveformTicks = detp.NumberTimeSamples();
  unsigned int const nReadoutWindowTicks = detp.ReadOutWindowSize();

  mf::LogVerbatim("detp_test") << "Electric field in the active volume: " << detp.Efield()
                               << " kV/cm"
                               << "\nSampling rate:       " << TDCtick << " ns"
                               << "\nArgon temperature:   " << detp.Temperature() << " K"
                               << "\nArgon density:       " << detp.Density() << " kg/dm^3 (at " << detp.Temperature() << " K)"
                               << "\nArgon density:       " << detp.Density(87.0) << " kg/dm^3 (at 87 K)"
                               << "\nDrift velocity:      " << driftVelocity << " cm/us"
                               << "\nReadout window:      " << nReadoutWindowTicks << " ticks ("
                               << (nReadoutWindowTicks * TDCtick / 1000) << " us)"
                               << "\nTPC waveform length: " << nWaveformTicks << " ticks ("
                               << (nWaveformTicks * TDCtick / 1000) << " us)";

  // accumulate the plane IDs; needed just for table formatting
  unsigned int headerColWidth = 0U;
  for (auto planeID : geom.IteratePlaneIDs()) {
    auto const l = std::string(planeID).length();
    if (headerColWidth < l) headerColWidth = l;
  }

  // print drift distances
  // collect all drift distances, and check whether they are all equal
  bool allSameDrift = true;
  lar::util::RealComparisons<double> check(1.0); // 1 cm tolerance
  auto driftDistances = geom.makeTPCData<double>();
  for (auto const& TPC : geom.IterateTPCs()) {
    auto const driftDistance = TPC.DriftDistance();
    driftDistances[TPC.ID()] = driftDistance;
    allSameDrift = allSameDrift & check.equal(driftDistance, driftDistances.first());
  } // for

  if (allSameDrift) {
    // print drift distance
    auto const driftDistance = driftDistances.first();
    auto const driftTime = driftDistance / driftVelocity;
    mf::LogVerbatim("detp_test") << "Drift distance:    " << driftDistance << " cm"
                                 << "\nDrift time:        " << driftTime << " us, "
                                 << (driftTime / (TDCtick / 1000.)) << " ticks";
  }
  else {
    // print drift distance table header
    mf::LogVerbatim log("detp_test");
    std::array<unsigned int, 4U> const columnSizes = {{headerColWidth, 9U, 13U, 7U}};
    log << std::setw(columnSizes[0]) << "Drift:"
        << " | " << std::setw(columnSizes[1]) << "time [us]"
        << " | " << std::setw(columnSizes[2]) << "distance [cm]"
        << " | " << std::setw(columnSizes[3]) << "ticks";

    // print drift distances by TPC
    for (auto const& TPCID : geom.IterateTPCIDs()) {
      auto const driftDistance = driftDistances[TPCID];
      auto const driftTime = driftDistance / driftVelocity;
      log << "\n"
          << std::setw(columnSizes[0]) << TPCID << " | " << std::setw(columnSizes[1]) << driftTime
          << " | " << std::setw(columnSizes[2]) << driftDistance << " | "
          << std::setw(columnSizes[3]) << (driftTime / (TDCtick / 1000.));
    } // for TPC
  }

  // 4. And finally we cross fingers.
  if (nErrors > 0) { mf::LogError("detp_test") << nErrors << " errors detected!"; }

  return nErrors;
} // main()