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/Geometry/ChannelMapAlg.h"
#include "larcorealg/Geometry/GeometryCore.h"
#include "larcorealg/TestUtils/unit_test_base.h"

// utility libraries
#include "fhiclcpp/ParameterSet.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

// CET libraries
#include "cetlib/filepath_maker.h"
#include "cetlib/filesystem.h" // cet::is_absolute_filepath()
#include "cetlib/search_path.h"

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

namespace testing {

  template <typename CHANNELMAP>
  struct BasicGeometryEnvironmentConfiguration : public BasicEnvironmentConfiguration {
    using ChannelMapClass = CHANNELMAP;

    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: {}  # empty parameter set for default
          )");
    } // LocalInit()

  }; // class BasicGeometryEnvironmentConfiguration<>

  template <typename ConfigurationClass>
  class GeometryTesterEnvironment : public TesterEnvironment<ConfigurationClass> {

    using TesterEnvironment_t = TesterEnvironment<ConfigurationClass>;

    using GeoResources_t = TestSharedGlobalResource<geo::GeometryCore const>;

  public:
    using SharedGeoPtr_t = GeoResources_t::ResourcePtr_t;

    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();
    }

    virtual ~GeometryTesterEnvironment();

    geo::GeometryCore const* Geometry() const { return geom.get(); }
    SharedGeoPtr_t SharedGeometry() const { return geom; }

    static geo::GeometryCore const* GlobalGeometry() { return &GeoResources_t::Resource(); }

    static SharedGeoPtr_t SharedGlobalGeometry() { return GeoResources_t::ShareResource(); }

  protected:
    using ChannelMapClass = typename ConfigurationClass::ChannelMapClass;

    virtual void Setup();

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

    virtual void RegisterGeometry(SharedGeoPtr_t new_geom);
    virtual void RegisterGeometry(geo::GeometryCore const* new_geom)
    {
      RegisterGeometry(SharedGeoPtr_t(new_geom));
    }

    virtual void SetupGeometry();

  private:
    ConfigurationClass config; 

    SharedGeoPtr_t geom; 

  }; // class GeometryTesterEnvironment<>

  //****************************************************************************
  template <typename ConfigurationClass>
  GeometryTesterEnvironment<ConfigurationClass>::~GeometryTesterEnvironment()
  {

    mf::LogInfo("Test") << config.ApplicationName() << " completed.";

  } // GeometryTesterEnvironment<>::~GeometryTesterEnvironment()

  template <typename ConfigurationClass>
  std::unique_ptr<geo::GeometryCore>
  GeometryTesterEnvironment<ConfigurationClass>::CreateNewGeometry() const
  {

    std::string ProviderParameterSetPath = this->Config().GeometryParameterSetPath();

    //
    // create the new geometry service provider
    //
    fhicl::ParameterSet ProviderConfig =
      this->Parameters().template get<fhicl::ParameterSet>(ProviderParameterSetPath);
    auto new_geom = std::make_unique<geo::GeometryCore>(ProviderConfig);

    std::string RelativePath = ProviderConfig.get<std::string>("RelativePath", "");

    std::string GDMLFileName = RelativePath + ProviderConfig.get<std::string>("GDML"),
                ROOTFileName = RelativePath + ProviderConfig.get<std::string>("ROOT");

    // Search all reasonable locations for the geometry file;
    // we see if by any chance art's FW_SEARCH_PATH directory is set and try
    // there;
    // if not, we do expect the path to be complete enough for ROOT to cope.
    cet::search_path sp("FW_SEARCH_PATH");

    std::string ROOTfile;
    if (!sp.find_file(ROOTFileName, ROOTfile)) ROOTfile = ROOTFileName;

    // we really don't care of GDML file, since we are not going to run Geant4
    std::string GDMLfile;
    if (!sp.find_file(GDMLFileName, GDMLfile)) {
      mf::LogWarning("CreateNewGeometry") << "GDML file '" << GDMLfile << "' not found.";
    }

    // initialize the geometry with the files we have found
    new_geom->LoadGeometryFile(GDMLfile, ROOTfile);

    //
    // create the new channel map
    //
    auto const SortingParameters = ProviderConfig.get<fhicl::ParameterSet>("SortingParameters", {});

    // connect the channel map with the geometry, that shares ownsership
    // (we give up ours at the end of this method)
    new_geom->ApplyChannelMap(std::make_unique<ChannelMapClass>(SortingParameters));

    return new_geom;
  } // GeometryTesterEnvironment<>::CreateNewGeometry()

  template <typename ConfigurationClass>
  void GeometryTesterEnvironment<ConfigurationClass>::RegisterGeometry(SharedGeoPtr_t new_geom)
  {
    // update the current geometry, that becomes owner;
    // also update the global one if it happens to be already our previous
    // (in this case, it becomes co-owner)
    SharedGeoPtr_t my_old_geom = geom;
    geom = new_geom;
    // if the global geometry is already the one we register, don't bother
    if (SharedGlobalGeometry() != new_geom)
      GeoResources_t::ReplaceDefaultSharedResource(my_old_geom, new_geom);
  } // GeometryTesterEnvironment<>::RegisterGeometry()

  template <typename ConfigurationClass>
  void GeometryTesterEnvironment<ConfigurationClass>::SetupGeometry()
  {
    //
    // horrible, shameful hack to support the "new" testing environment
    // while the old one, informally deprecated, is still around;
    // we will have TWO versions of GeometryCore around.
    // Ugh.
    //
    RegisterGeometry(CreateNewGeometry()); // old
    // new
    this->template AcquireProvider<geo::GeometryCore>(CreateNewGeometry());
  } // GeometryTesterEnvironment<>::SetupGeometry()

  template <typename ConfigurationClass>
  void GeometryTesterEnvironment<ConfigurationClass>::Setup()
  {

    //
    // parse configuration, set up message facility
    //
    TesterEnvironment_t::Setup();

    //
    // set up the geometry
    //
    SetupGeometry();

    mf::LogInfo("Test") << config.ApplicationName() << " Geometry setup complete.";

  } // GeometryTesterEnvironment<>::Setup()

} // namespace testing

#endif // TEST_GEOMETRY_UNIT_TEST_BASE_H