geometry_unit_test_base.h

Go to the documentation of this file.

#ifndef TEST_GEOMETRY_UNIT_TEST_BASE_H
#define TEST_GEOMETRY_UNIT_TEST_BASE_H

// LArSoft libraries
#include "larcorealg/CoreUtils/SearchPathPlusRelative.h"
#include "larcorealg/Geometry/GeometryBuilderStandard.h"
#include "larcorealg/Geometry/GeometryCore.h"
#include "larcorealg/TestUtils/unit_test_base.h"

// Framework libraries
#include "cetlib/search_path.h"
#include "fhiclcpp/ParameterSet.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

// C/C++ standard libraries
#include <iostream> // for output before message facility is set up
#include <map>
#include <memory> // std::unique_ptr<>
#include <string>
#include <type_traits>

namespace testing {

  struct BasicGeometryEnvironmentConfiguration : public BasicEnvironmentConfiguration {

    BasicGeometryEnvironmentConfiguration() : BasicEnvironmentConfiguration() { LocalInit(); }

    BasicGeometryEnvironmentConfiguration(int argc, char** argv)
      : BasicEnvironmentConfiguration(argc, argv)
    {
      LocalInit();
    }

    BasicGeometryEnvironmentConfiguration(std::string name) : BasicEnvironmentConfiguration(name)
    {
      LocalInit();
    }

    BasicGeometryEnvironmentConfiguration(int argc, char** argv, std::string name)
      : BasicEnvironmentConfiguration(argc, argv, name)
    {
      LocalInit();
    }

    std::string GeometryParameterSetPath() const
    {
      return ServiceParameterSetPath(GeometryServiceName());
    }

    std::string DefaultGeometryConfiguration() const
    {
      return DefaultServiceConfiguration(GeometryServiceName());
    }



    void SetGeometryParameterSetPath(std::string path)
    {
      SetServiceParameterSetPath(GeometryServiceName(), path);
    }

    void SetDefaultGeometryConfiguration(std::string cfg)
    {
      AddDefaultServiceConfiguration(GeometryServiceName(), cfg);
    }


    static std::string GeometryServiceName() { return "Geometry"; }

  protected:
    void LocalInit()
    {
      SetDefaultGeometryConfiguration(R"(
          SurfaceY:        200.  # in cm, vertical distance to the surface
          Name:            "lartpcdetector"
          GDML:            "LArTPCdetector.gdml"
          ROOT:            "LArTPCdetector.gdml"
          SortingParameters: { tool_type: GeoObjectSorterStandard }
          )");
    } // LocalInit()

  }; // class BasicGeometryEnvironmentConfiguration<>

  template <typename ConfigurationClass, typename ObjectSorter>
  class GeometryTesterEnvironment : public TesterEnvironment<ConfigurationClass> {
    using TesterEnvironment_t = TesterEnvironment<ConfigurationClass>;

  public:
    GeometryTesterEnvironment(bool bSetup = true) : TesterEnvironment_t(false)
    {
      if (bSetup) Setup();
    }


    GeometryTesterEnvironment(ConfigurationClass const& cfg_obj, bool bSetup = true)
      : TesterEnvironment_t(cfg_obj, false)
    {
      if (bSetup) Setup();
    }
    GeometryTesterEnvironment(ConfigurationClass&& cfg_obj, bool bSetup = true)
      : TesterEnvironment_t(std::move(cfg_obj), false)
    {
      if (bSetup) Setup();
    }

    geo::GeometryCore const* Geometry() const noexcept
    {
      return this->template Provider<geo::GeometryCore>();
    }

    virtual ~GeometryTesterEnvironment();

  protected:
    void Setup();

    virtual std::unique_ptr<geo::GeometryCore> CreateNewGeometry() const;

  private:
    ConfigurationClass config; 

  }; // class GeometryTesterEnvironment<>

  template <typename ObjectSorter>
  auto createSorter(fhicl::ParameterSet const& pset [[maybe_unused]])
  {
    if constexpr (std::is_constructible_v<ObjectSorter>) {
      return std::make_unique<ObjectSorter>();
    }
    else if constexpr (std::is_constructible_v<ObjectSorter, fhicl::ParameterSet>) {
      return std::make_unique<ObjectSorter>(pset);
    }
  }

  //****************************************************************************
  template <typename ConfigurationClass, typename ObjectSorter>
  GeometryTesterEnvironment<ConfigurationClass, ObjectSorter>::~GeometryTesterEnvironment()
  {
    mf::LogInfo("Test") << config.ApplicationName() << " completed.";
  }

  template <typename ConfigurationClass, typename ObjectSorter>
  std::unique_ptr<geo::GeometryCore>
  GeometryTesterEnvironment<ConfigurationClass, ObjectSorter>::CreateNewGeometry() const
  {
    std::string ProviderParameterSetPath = this->Config().GeometryParameterSetPath();

    fhicl::ParameterSet ProviderConfig =
      this->Parameters().template get<fhicl::ParameterSet>(ProviderParameterSetPath);

    return std::make_unique<geo::GeometryCore>(
      ProviderConfig,
      std::make_unique<geo::GeometryBuilderStandard>(
        ProviderConfig.get<fhicl::ParameterSet>("Builder", {})),
      createSorter<ObjectSorter>(ProviderConfig.get<fhicl::ParameterSet>("SortingParameters", {})));
  }

  template <typename ConfigurationClass, typename ObjectSorter>
  void GeometryTesterEnvironment<ConfigurationClass, ObjectSorter>::Setup()
  {
    TesterEnvironment_t::Setup();
    this->AcquireProvider(CreateNewGeometry());
    mf::LogInfo("Test") << config.ApplicationName() << " Geometry setup complete.";
  }

} // namespace testing

#endif // TEST_GEOMETRY_UNIT_TEST_BASE_H