detinfo::DetectorClocksServiceStandard Class Reference

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

#include "DetectorClocksServiceStandard.h"

Inheritance diagram for detinfo::DetectorClocksServiceStandard:

Public Types
typedef detinfo::DetectorClocks	provider_type

Public Member Functions
	DetectorClocksServiceStandard (fhicl::ParameterSet const &pset, art::ActivityRegistry &reg)
virtual void	reconfigure (fhicl::ParameterSet const &pset) override
void	preBeginRun (const art::Run &run)
void	preProcessEvent (const art::Event &evt)
void	postOpenFile (const std::string &filename)
virtual const provider_type *	provider () const override

Private Attributes
std::unique_ptr< detinfo::DetectorClocksStandard >	fClocks

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:

if the past jobs (explicitly excluding the current job) had inconsistent

configuration, an exception is thrown claiming an "historical disagreement"

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:

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

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 85 of file DetectorClocksServiceStandard.h.

Member Typedef Documentation

typedef detinfo::DetectorClocks detinfo::DetectorClocksService::provider_type

inherited

Definition at line 22 of file DetectorClocksService.h.

Constructor & Destructor Documentation

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

Definition at line 9 of file DetectorClocksServiceStandard_service.cc.

References art::ActivityRegistry::sPostOpenFile, art::ActivityRegistry::sPreBeginRun, and art::ActivityRegistry::sPreProcessEvent.

  : fClocks(std::make_unique<detinfo::DetectorClocksStandard>(pset))
{
  
  reg.sPreProcessEvent.watch (this, &DetectorClocksServiceStandard::preProcessEvent);
  reg.sPostOpenFile.watch    (this, &DetectorClocksServiceStandard::postOpenFile);
  reg.sPreBeginRun.watch     (this, &DetectorClocksServiceStandard::preBeginRun);
  
}

Member Function Documentation

void detinfo::DetectorClocksServiceStandard::postOpenFile

(

const std::string &

filename

)

Definition at line 45 of file DetectorClocksServiceStandard_service.cc.

References DEFINE_ART_SERVICE_INTERFACE_IMPL, fClocks, file, fhicl::ParameterSet::get(), detinfo::kInheritConfigTypeMax, and fhicl::make_ParameterSet().

{

  // Method inheriting from DetectorProperties
  
  if(!fClocks->InheritClockConfig()) return;

  // The only way to access art service metadata from the input file
  // is to open it as a separate TFile object.  Do that now.
  
  if(!filename.empty()) {
    
    TFile* file = TFile::Open(filename.c_str(), "READ");
    if(file != 0 && !file->IsZombie() && file->IsOpen()) {

      std::vector<std::string> cfgName = fClocks->ConfigNames();
      std::vector<double> cfgValue = fClocks->ConfigValues();
      
      // Open the sqlite datatabase.
      
      art::SQLite3Wrapper sqliteDB(file, "RootFileDB");
      
      // Loop over all stored ParameterSets.

      std::vector<size_t> config_count(detinfo::kInheritConfigTypeMax,0);
      std::vector<double> config_value(detinfo::kInheritConfigTypeMax,0);

      sqlite3_stmt * stmt = 0;
      sqlite3_prepare_v2(sqliteDB, "SELECT PSetBlob from ParameterSets;", -1, &stmt, NULL);

      while (sqlite3_step(stmt) == SQLITE_ROW) {

        fhicl::ParameterSet ps;
        fhicl::make_ParameterSet(reinterpret_cast<char const *>(sqlite3_column_text(stmt, 0)), ps);

        if(!fClocks->IsRightConfig(ps)) continue;

        for(size_t i=0; i<detinfo::kInheritConfigTypeMax; ++i) {

          double value_from_file = ps.get<double>(cfgName.at(i).c_str());
          
          if(!(config_count.at(i)))

            config_value.at(i) = value_from_file;

          else if(config_value.at(i) != value_from_file)

            throw cet::exception(__FUNCTION__) << Form("\033[95mFound historical value disagreement for %s ... %g != %g",
                                                       cfgName.at(i).c_str(),
                                                       config_value.at(i),
                                                       value_from_file)
                                               << "\033[00m" << std::endl;
          config_count.at(i) +=1;

        }
        
      }

      // Override parameters 

      for(size_t i=0; i<detinfo::kInheritConfigTypeMax; ++i)

        if(config_count.at(i) && cfgValue.at(i) != config_value.at(i)) {

          std::cout  << Form("\033[93mOverriding configuration parameter %s ... %g (fcl) => %g (data file)\033[00m",
                             cfgName.at(i).c_str(),
                             cfgValue.at(i),
                             config_value.at(i))
                     << std::endl;
          
          fClocks->SetConfigValue(i,config_value.at(i));
          
        }
    }
    
    // Close file.
    if(file != 0) {
      if(file->IsOpen())
        file->Close();
      delete file;
    }
  }

  // Reset parameters
  fClocks->ApplyParams();

}

void detinfo::DetectorClocksServiceStandard::preBeginRun

(

const art::Run &

run

)

Definition at line 35 of file DetectorClocksServiceStandard_service.cc.

References fClocks.

{

  fClocks->ApplyParams();

}

void detinfo::DetectorClocksServiceStandard::preProcessEvent

(

const art::Event &

evt

)

Definition at line 28 of file DetectorClocksServiceStandard_service.cc.

References fClocks, and detinfo::setDetectorClocksStandardTrigger().

{
  detinfo::setDetectorClocksStandardTrigger(*fClocks, evt);
}

virtual const provider_type* detinfo::DetectorClocksServiceStandard::provider ( ) const

inlineoverridevirtual

Implements detinfo::DetectorClocksService.

Definition at line 94 of file DetectorClocksServiceStandard.h.

References fClocks.

{ return fClocks.get();}

void detinfo::DetectorClocksServiceStandard::reconfigure ( fhicl::ParameterSet const &  pset )

overridevirtual

Implements detinfo::DetectorClocksService.

Definition at line 20 of file DetectorClocksServiceStandard_service.cc.

References fClocks.

{
  fClocks->Configure(pset);

}

Member Data Documentation

std::unique_ptr<detinfo::DetectorClocksStandard> detinfo::DetectorClocksServiceStandard::fClocks

private

Definition at line 98 of file DetectorClocksServiceStandard.h.

Referenced by postOpenFile(), preBeginRun(), preProcessEvent(), provider(), and reconfigure().

---

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

• lardata/v06_47_03/source/lardata/DetectorInfoServices/DetectorClocksServiceStandard.h
• lardata/v06_47_03/source/lardata/DetectorInfoServices/DetectorClocksServiceStandard_service.cc