detinfo::DetectorClocksServiceStandard Class Reference

art service managing detinfo::DetectorClocksStandard. More...

#include "DetectorClocksServiceStandard.h"

Inheritance diagram for detinfo::DetectorClocksServiceStandard:

Public Types
using	provider_type = detinfo::DetectorClocks

Public Member Functions
	DetectorClocksServiceStandard (fhicl::ParameterSet const &pset, art::ActivityRegistry &reg)

Private Member Functions
void	preBeginRun (art::Run const &run)
void	postOpenFile (std::string const &filename)
DetectorClocksData	DataForJob () const override
DetectorClocksData	DataFor (art::Event const &e) const override

Private Attributes
DetectorClocksStandard	fClocks
bool	fInheritClockConfig

Detailed Description

art service managing detinfo::DetectorClocksStandard.

See also

detinfo::DetectorClocksStandard, detinfo::DetectorClocks

This art service manages LArSoft's service provider detinfo::DetectorClocksStandard, which implements detinfo::DetectorClocks interface.

For information about functionality of the service, see the documentation of its interface, detinfo::DetectorClocks. For information of the configuration, see also detinfo::DetectorClocksStandard.

Configuration

The configuration parameters are documented in the service provider implementation: detinfo::DetectorClocksStandard.

Consistency check

This service manager honors the InheritClockConfig configuration option in the following way:

1. if the past jobs (explicitly excluding the current job) had inconsistent configuration, an exception is thrown claiming an "historical disagreement"
2. after the verification that the past configuration is consistent, the values from that configurations override the ones in the configuration of the current job; a value from the configuration of the current job is retained only if it was not present in the past (i.e. it is a new configuration parameter added since the input file was produced).

The "past jobs" are the jobs that have produced the input file, and whose configuration is stored by art in the input file itself. The check and reconfiguration is performed on each new input file.

Timing specifics

The trigger and beam gate times are set by this service before each event is processed. The logic is the following:

1. if the event contains a raw trigger (raw::Trigger) data product with input tag TriggerName() (from the configuration), that data product is read and the trigger and beam gate times stored in it are imported in the current service provider configuration; if there are more than one raw::Trigger objects in the data product, an exception is thrown
2. if no raw trigger is found with the specified label, the configuration of the service provider is updated using the default values of trigger and beam times specified in the service configuration

The first set up happens on opening the first run in the first input file. Accessing this service before (e.g. during beginJob() phase) yields undefined behaviour.

Definition at line 87 of file DetectorClocksServiceStandard.h.

Member Typedef Documentation

using detinfo::DetectorClocksService::provider_type = detinfo::DetectorClocks

inherited

Definition at line 23 of file DetectorClocksService.h.

Constructor & Destructor Documentation

detinfo::DetectorClocksServiceStandard::DetectorClocksServiceStandard	(	fhicl::ParameterSet const &	pset,
		art::ActivityRegistry &	reg
	)

Definition at line 35 of file DetectorClocksServiceStandard.cc.

References fInheritClockConfig, postOpenFile(), and preBeginRun().

    : fClocks{pset}, fInheritClockConfig{pset.get<bool>("InheritClockConfig")}
  {
    reg.sPostOpenFile.watch(this, &DetectorClocksServiceStandard::postOpenFile);
    reg.sPreBeginRun.watch(this, &DetectorClocksServiceStandard::preBeginRun);
  }

Member Function Documentation

DetectorClocksData detinfo::DetectorClocksServiceStandard::DataFor ( art::Event const &  e ) const

overrideprivatevirtual

Implements detinfo::DetectorClocksService.

Definition at line 125 of file DetectorClocksServiceStandard.cc.

References detinfo::detectorClocksStandardDataFor(), and fClocks.

  {
    return detinfo::detectorClocksStandardDataFor(fClocks, e);
  }

DetectorClocksData detinfo::DetectorClocksServiceStandard::DataForJob ( ) const

inlineoverrideprivatevirtual

Implements detinfo::DetectorClocksService.

Definition at line 95 of file DetectorClocksServiceStandard.h.

References e.

{ return fClocks.DataForJob(); }

void detinfo::DetectorClocksServiceStandard::postOpenFile ( std::string const &  filename )

private

Definition at line 49 of file DetectorClocksServiceStandard.cc.

References detinfo::DetectorClocksStandard::ApplyParams(), detinfo::DetectorClocksStandard::ConfigNames(), detinfo::DetectorClocksStandard::ConfigValues(), fClocks, file, fInheritClockConfig, detinfo::DetectorClocksStandard::IsRightConfig(), detinfo::kConfigTypeMax, fhicl::ParameterSet::make(), art::rootNames::metaDataTreeName(), and detinfo::DetectorClocksStandard::SetConfigValue().

Referenced by DetectorClocksServiceStandard().

  {
    if (!fInheritClockConfig) { return; }
    if (filename.empty()) { return; }
    std::unique_ptr<TFile> file{TFile::Open(filename.c_str(), "READ")};
    if (!file || file->IsZombie() || !file->IsOpen()) { return; }
    std::unique_ptr<TTree> metaDataTree{
      file->Get<TTree>(art::rootNames::metaDataTreeName().c_str())};
    if (metaDataTree == nullptr) {
      throw cet::exception("DetectorClocksServiceStandard",
                           "Input file does not contain a metadata tree!");
    }
    auto const fileFormatVersion =
      art::detail::readMetadata<art::FileFormatVersion>(metaDataTree.get());
    fhicl::ParameterSet ps;
    vector<string> const cfgName(fClocks.ConfigNames());
    vector<double> const cfgValue(fClocks.ConfigValues());
    bitset<kConfigTypeMax> config_set;
    vector<double> config_value(kConfigTypeMax, 0);

    auto count_configuration_changes =
      [&cfgName, &config_set, &config_value](fhicl::ParameterSet const& ps) {
        for (size_t i = 0; i < kConfigTypeMax; ++i) {
          auto const value_from_file = ps.get<double>(cfgName[i]);
          if (not config_set[i]) {
            config_value[i] = value_from_file;
            config_set[i] = true;
          }
          else if (config_value[i] != value_from_file) {
            throw cet::exception("DetectorClocksServiceStandard")
              << "Found historical value disagreement for " << cfgName[i] << " ... "
              << config_value[i] << " != " << value_from_file;
          }
        }
      };

    if (fileFormatVersion.value_ < 5) {
      art::ParameterSetMap psetMap;
      if (!art::detail::readMetadata(metaDataTree.get(), psetMap)) {
        throw cet::exception("DetectorClocksServiceStandard",
                             "Could not read ParameterSetMap from metadata tree!");
      }

      for (auto const& psEntry : psetMap) {
        fhicl::ParameterSet ps;
        ps = fhicl::ParameterSet::make(psEntry.second.pset_);
        if (!fClocks.IsRightConfig(ps)) { continue; }

        count_configuration_changes(ps);
      }
    }
    else {
      art::SQLite3Wrapper sqliteDB(file.get(), "RootFileDB");
      sqlite3_stmt* stmt{nullptr};
      sqlite3_prepare_v2(sqliteDB, "SELECT PSetBlob from ParameterSets;", -1, &stmt, nullptr);
      while (sqlite3_step(stmt) == SQLITE_ROW) {
        fhicl::ParameterSet ps;
        ps = fhicl::ParameterSet::make(reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0)));
        if (!fClocks.IsRightConfig(ps)) { continue; }

        count_configuration_changes(ps);
      }
      sqlite3_finalize(stmt);
    }

    for (size_t i = 0; i < kConfigTypeMax; ++i) {
      if (not config_set[i]) continue;
      if (cfgValue[i] == config_value[i]) continue;

      cout << "Overriding configuration parameter " << cfgName[i] << " ... " << cfgValue[i]
           << " (fcl) => " << config_value[i] << " (data file)" << endl;
      fClocks.SetConfigValue(i, config_value[i]);
    }
    fClocks.ApplyParams();
  } // DetectorClocksServiceStandard::postOpenFile()

void detinfo::DetectorClocksServiceStandard::preBeginRun ( art::Run const &  run )

private

Definition at line 43 of file DetectorClocksServiceStandard.cc.

References detinfo::DetectorClocksStandard::ApplyParams(), and fClocks.

Referenced by DetectorClocksServiceStandard().

  {
    // This callback probably is not necessary.
    fClocks.ApplyParams();
  }

Member Data Documentation

DetectorClocksStandard detinfo::DetectorClocksServiceStandard::fClocks

private

Definition at line 99 of file DetectorClocksServiceStandard.h.

Referenced by DataFor(), postOpenFile(), and preBeginRun().

bool detinfo::DetectorClocksServiceStandard::fInheritClockConfig

private

Definition at line 100 of file DetectorClocksServiceStandard.h.

Referenced by DetectorClocksServiceStandard(), and postOpenFile().

---

The documentation for this class was generated from the following files:

• lardata/v09_16_03/source/lardata/DetectorInfoServices/DetectorClocksServiceStandard.h
• lardata/v09_16_03/source/lardata/DetectorInfoServices/DetectorClocksServiceStandard.cc