GeometryConfigurationWriter_service.cc

Go to the documentation of this file.

// LArSoft libraries
#include "larcore/Geometry/Geometry.h"
#include "larcoreobj/SummaryData/GeometryConfigurationInfo.h"
#include "larcoreobj/SummaryData/RunData.h"

// framework libraries
#include "art/Framework/Core/ProducingService.h"
#include "art/Framework/Principal/Handle.h"
#include "art/Framework/Principal/Run.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "canvas/Utilities/InputTag.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

// C/C++ standard libraries
#include <memory>  // std::make_unique()
#include <utility> // std::move()

// -----------------------------------------------------------------------------
namespace geo {
  class GeometryConfigurationWriter;
}
class geo::GeometryConfigurationWriter : public art::ProducingService {

public:
  struct Config {
    // no configuration parameters at this time
  };

  using Parameters = art::ServiceTable<Config>;

  GeometryConfigurationWriter(Parameters const&);

private:
  virtual void postReadRun(art::Run& run) override;

private:
  using InfoPtr_t = std::unique_ptr<sumdata::GeometryConfigurationInfo>;

  InfoPtr_t loadInfo(art::Run& run) const;

  static InfoPtr_t extractInfoFromGeometry();

  InfoPtr_t readGeometryInformation(art::Run& run) const;

  InfoPtr_t makeInfoFromRunData(art::Run& run) const;

  sumdata::RunData const* readRunData(art::Run& run) const;

  static InfoPtr_t convertRunDataToGeometryInformation(sumdata::RunData const& data);

  static InfoPtr_t makeInfoPtr(sumdata::GeometryConfigurationInfo const& info)
  {
    return std::make_unique<sumdata::GeometryConfigurationInfo>(info);
  }

}; // geo::GeometryConfigurationWriter

// -----------------------------------------------------------------------------
// --- implementation
// -----------------------------------------------------------------------------
geo::GeometryConfigurationWriter::GeometryConfigurationWriter(Parameters const&)
{
  produces<sumdata::GeometryConfigurationInfo, art::InRun>();
}

// -----------------------------------------------------------------------------
void geo::GeometryConfigurationWriter::postReadRun(art::Run& run)
{

  InfoPtr_t confInfo = geo::GeometryConfigurationWriter::loadInfo(run);

  if (!confInfo) confInfo = extractInfoFromGeometry();

  run.put(std::move(confInfo), art::fullRun());

} // geo::GeometryConfigurationWriter::postReadRun()

// -----------------------------------------------------------------------------
auto geo::GeometryConfigurationWriter::loadInfo(art::Run& run) const -> InfoPtr_t
{

  /*
   * Read geometry configuration information from the run:
   *
   * 1. first attempt to directly read information from past runs of this
   *    service
   * 2. if none is found, attempt reading legacy information and upgrade it
   * 3. if no legacy information is found either, return a null pointer
   *
   */
  InfoPtr_t info = readGeometryInformation(run);

  return info ? std::move(info) : makeInfoFromRunData(run);

} // geo::GeometryConfigurationWriter::loadInfo()

// -----------------------------------------------------------------------------
auto geo::GeometryConfigurationWriter::extractInfoFromGeometry() -> InfoPtr_t
{

  sumdata::GeometryConfigurationInfo confInfo =
    art::ServiceHandle<geo::Geometry>()->configurationInfo();

  MF_LOG_DEBUG("GeometryConfigurationWriter")
    << "Geometry configuration information from service:\n"
    << confInfo;

  return makeInfoPtr(std::move(confInfo));

} // geo::GeometryConfigurationWriter::extractInfoFromGeometry()

// -----------------------------------------------------------------------------
auto geo::GeometryConfigurationWriter::readGeometryInformation(art::Run& run) const -> InfoPtr_t
{

  art::Handle<sumdata::GeometryConfigurationInfo> infoHandle;
  return run.getByLabel(art::InputTag{"GeometryConfigurationWriter"}, infoHandle) ?
           makeInfoPtr(*infoHandle) :
           InfoPtr_t{};

} // geo::GeometryConfigurationWriter::hasGeometryInformation()

// -----------------------------------------------------------------------------
auto geo::GeometryConfigurationWriter::makeInfoFromRunData(art::Run& run) const -> InfoPtr_t
{

  sumdata::RunData const* runData = readRunData(run);

  return runData ? convertRunDataToGeometryInformation(*runData) : InfoPtr_t{};

} // geo::GeometryConfigurationWriter::makeInfoFromRunData()

// -----------------------------------------------------------------------------
sumdata::RunData const* geo::GeometryConfigurationWriter::readRunData(art::Run& run) const
{
  //std::vector<art::Handle<sumdata::RunData>> allRunData;
  //run.getManyByType(allRunData);
  auto allRunData = run.getMany<sumdata::RunData>();
  return allRunData.empty() ? nullptr : allRunData.front().product();
} // geo::GeometryConfigurationWriter::readRunData()

// -----------------------------------------------------------------------------
auto geo::GeometryConfigurationWriter::convertRunDataToGeometryInformation(
  sumdata::RunData const& data) -> InfoPtr_t
{

  sumdata::GeometryConfigurationInfo confInfo;

  // we use the simplest version 1 data format (legacy format)
  confInfo.dataVersion = sumdata::GeometryConfigurationInfo::DataVersion_t{1};
  confInfo.detectorName = data.DetName();

  MF_LOG_DEBUG("GeometryConfigurationInfo")
    << "Built geometry configuration information from run data:\n"
    << confInfo;

  return makeInfoPtr(std::move(confInfo));

} // geo::GeometryConfigurationWriter::convertRunDataToGeometryInformation()

// -----------------------------------------------------------------------------
DEFINE_ART_PRODUCING_SERVICE(geo::GeometryConfigurationWriter)

// -----------------------------------------------------------------------------