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 "cetlib/HorizontalRule.h"
#include "fhiclcpp/types/Atom.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 {
    fhicl::Atom<bool> SkipConfigurationCheck{fhicl::Name("SkipConfigurationCheck"), false};
  };
  using Parameters = art::ServiceTable<Config>;

  GeometryConfigurationWriter(Parameters const&);

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

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

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

  static InfoPtr_t extractInfoFromGeometry();

  void verifyConsistentConfigs(sumdata::GeometryConfigurationInfo const& A,
                               sumdata::GeometryConfigurationInfo const& B,
                               art::RunID const& id) const;

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

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

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

  bool fFatalConfCheck;

}; // geo::GeometryConfigurationWriter

// -----------------------------------------------------------------------------
// --- implementation
// -----------------------------------------------------------------------------

namespace {
  // ---------------------------------------------------------------------------
  auto makeInfoPtr(sumdata::GeometryConfigurationInfo info)
  {
    return std::make_unique<sumdata::GeometryConfigurationInfo>(std::move(info));
  }

  // ---------------------------------------------------------------------------
  // Converts the legacy `data` into geometry configuration information.
  auto convertRunDataToGeometryInformation(sumdata::RunData const& data)
  {
    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));
  }

  //......................................................................
  // Returns if `A` and `B` are compatible geometry service configurations.
  bool compareConfigurationInfo(sumdata::GeometryConfigurationInfo const& A,
                                sumdata::GeometryConfigurationInfo const& B)
  {
    if (!A.isDataValid()) {
      mf::LogWarning("GeometryConfiguration") << "invalid version for configuration A:\n" << A;
      return false;
    }
    if (!B.isDataValid()) {
      mf::LogWarning("GeometryConfiguration") << "invalid version for configuration B:\n" << B;
      return false;
    }

    // currently used only in debug mode (assert())
    [[maybe_unused]] auto const commonVersion = std::min(A.dataVersion, B.dataVersion);

    assert(commonVersion >= 1);

    if (A.detectorName != B.detectorName) { // case sensitive so far
      mf::LogWarning("GeometryConfiguration")
        << "detector name mismatch: '" << A.detectorName << "' vs. '" << B.detectorName << "'";
      return false;
    }

    return true;
  }

}

// -----------------------------------------------------------------------------
geo::GeometryConfigurationWriter::GeometryConfigurationWriter(Parameters const& p)
  : fFatalConfCheck{not p().SkipConfigurationCheck()}
{
  produces<sumdata::GeometryConfigurationInfo, art::InRun>();
}

// -----------------------------------------------------------------------------
void geo::GeometryConfigurationWriter::postReadRun(art::Run& run)
{
  auto previousConfInfo = previousInfo(run);
  auto currentConfInfo = extractInfoFromGeometry();
  if (previousConfInfo && currentConfInfo) {
    verifyConsistentConfigs(*previousConfInfo, *currentConfInfo, run.id());
  }

  InfoPtr_t confInfo = previousConfInfo ? std::move(previousConfInfo) : std::move(currentConfInfo);
  run.put(std::move(confInfo), art::fullRun());
}

// -----------------------------------------------------------------------------
auto geo::GeometryConfigurationWriter::previousInfo(art::Run const& run) const -> InfoPtr_t
{
  InfoPtr_t info = readGeometryInformation(run);
  return info ? std::move(info) : makeInfoFromRunData(run);
}

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

// -----------------------------------------------------------------------------
void geo::GeometryConfigurationWriter::verifyConsistentConfigs(
  sumdata::GeometryConfigurationInfo const& A,
  sumdata::GeometryConfigurationInfo const& B,
  art::RunID const& id) const
{
  auto consistentInfo = compareConfigurationInfo(A, B);
  if (consistentInfo) { return; }

  if (fFatalConfCheck) {
    cet::HorizontalRule rule{50};
    throw cet::exception("GeometryConfiguration")
      << "Geometry used for run " << id << " is incompatible with the one configured in the job!"
      << "\n=== job configuration " << rule('=') << "\n"
      << B << "\n=== run configuration " << rule('=') << "\n"
      << A << "\n======================" << rule('=') << "\n";
  }
  mf::LogWarning("GeometryConfiguration")
    << "Geometry used for " << id << " is incompatible with the one configured in the job.";
}

// -----------------------------------------------------------------------------
auto geo::GeometryConfigurationWriter::readGeometryInformation(art::Run const& run) const
  -> InfoPtr_t
{
  if (auto h = run.getHandle<sumdata::GeometryConfigurationInfo>(
        art::InputTag{"GeometryConfigurationWriter"})) {
    return makeInfoPtr(*h);
  }
  return nullptr;
}

// -----------------------------------------------------------------------------
auto geo::GeometryConfigurationWriter::makeInfoFromRunData(art::Run const& run) const -> InfoPtr_t
{
  sumdata::RunData const* runData = readRunData(run);
  return runData ? convertRunDataToGeometryInformation(*runData) : InfoPtr_t{};
}

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

DEFINE_ART_PRODUCING_SERVICE(geo::GeometryConfigurationWriter)