"Standard" implementation of DetectorProperties service More...

#include <DetectorPropertiesServiceStandardGAr.h>

Inheritance diagram for gar::detinfo::DetectorPropertiesServiceStandardGAr:

Classes
struct	ServiceConfiguration_t

Public Types
using	Parameters = ::art::ServiceTable< ServiceConfiguration_t >

Public Types inherited from gar::detinfo::DetectorPropertiesService
typedef detinfo::DetectorProperties	provider_type

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

virtual void	reconfigure (fhicl::ParameterSet const &pset) override

void	preProcessEvent (::art::Event const &evt, art::ScheduleContext)

void	postOpenFile (std::string const &filename)

virtual const provider_type *	provider () const override

Public Member Functions inherited from gar::detinfo::DetectorPropertiesService
virtual	~DetectorPropertiesService ()=default

Private Member Functions
bool	isDetectorPropertiesServiceStandardGAr (const fhicl::ParameterSet &ps) const

Private Attributes
std::unique_ptr< detinfo::DetectorPropertiesStandard >	fProp

fhicl::ParameterSet	fPS
	Original parameter set. More...

bool	fInheritNumberTimeSamples
	Flag saying whether to inherit NumberTimeSamples. More...

Detailed Description

"Standard" implementation of DetectorProperties service

This class wraps DetectorPropertiesStandard provider into a art service. It delivers the provider via the standard interface:

detinfo::DetectorProperties const* detprop
  = ::art::ServiceHandle<detinfo::DetectorPropertiesStandard>()
  ->provider();

or, using the standard interface in "CoreUtils/ServiceUtil.h":

auto const* detprop
  = gar::providerFrom<detinfo::DetectorPropertiesStandard>();

In addition to the functionality of the provider, this service allows to read the configuration from the input file, inherited from a previous run.

Configuration parameters

This service passes the whole configuration down to its service provider, but it also reacts to:

InheritNumberTimeSamples (boolean; default: false): if true, the configuration database in the ROOT input file is queried and if a configuration for this service is found, it's used instead of the one from the current FHiCL configuration

Definition at line 60 of file DetectorPropertiesServiceStandardGAr.h.

Member Typedef Documentation

using gar::detinfo::DetectorPropertiesServiceStandardGAr::Parameters = ::art::ServiceTable<ServiceConfiguration_t>

Definition at line 82 of file DetectorPropertiesServiceStandardGAr.h.

Constructor & Destructor Documentation

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

Definition at line 29 of file DetectorPropertiesServiceStandardGAr_service.cc.

     : fInheritNumberTimeSamples(pset.get<bool>("InheritNumberTimeSamples", false))
     {
       // Register for callbacks.
 
       reg.sPostOpenFile.watch    (this, &DetectorPropertiesServiceStandardGAr::postOpenFile);
       reg.sPreProcessEvent.watch (this, &DetectorPropertiesServiceStandardGAr::preProcessEvent);
       fProp = std::make_unique<detinfo::DetectorPropertiesStandard>(pset,
                                                                     gar::extractProviders<geo::GeometryGAr,
                                                                                           detinfo::GArPropertiesService,
                                                                                           detinfo::ECALPropertiesService,
                                                                                           detinfo::DetectorClocksServiceGAr>(),
                                                                     std::set<std::string>({ "InheritNumberTimeSamples" })
                                                                     );
 
       // at this point we need and expect the provider to be fully configured
       fProp->CheckIfConfigured();
 
       // Save the parameter set.
       fPS = pset;
 
     }

Member Function Documentation

bool gar::detinfo::DetectorPropertiesServiceStandardGAr::isDetectorPropertiesServiceStandardGAr ( const fhicl::ParameterSet & ps ) const

private

Definition at line 180 of file DetectorPropertiesServiceStandardGAr_service.cc.

     {
       // This method uses heuristics to determine whether the parameter
       // set passed as argument is a DetectorPropertiesService configuration
       // parameter set.
 
       return
       (ps.get<std::string>("service_type", "") == "DetectorPropertiesService")
       && (ps.get<std::string>("service_provider", "") == "DetectorPropertiesServiceStandardGAr")
       ;
 #if 0
       // old heuristics here:
       std::string s;
       double d;
       int i;
       unsigned int u;
 
       bool result = !ps.get_if_present("module_label", s);
       result = result && ps.get_if_present("TriggerOffset", i);
       result = result && ps.get_if_present("SamplingRate", d);
       result = result && ps.get_if_present("NumberTimeSamples", u);
 
       return result;
 #endif // 0
     }

void gar::detinfo::DetectorPropertiesServiceStandardGAr::postOpenFile ( std::string const & filename )

Definition at line 74 of file DetectorPropertiesServiceStandardGAr_service.cc.

     {
       // Use this method to figure out whether to inherit configuration
       // parameters from previous jobs.
 
       // There is no way currently to correlate parameter sets saved in
       // sqlite RootFileDB with process history (from MetaData tree).
       // Therefore, we use the approach of scanning every historical
       // parameter set in RootFileDB, and finding all parameter sets
       // that appear to be DetectorPropertiesService configurations.  If all
       // historical parameter sets are in agreement about the value of
       // an inherited parameter, then we accept the historical value,
       // print a message, and override the configuration parameter.  In
       // cases where the historical configurations are not in agreement
       // about the value of an inherited parameter, we ignore any
       // historical parameter values that are the same as the current
       // configured value of the parameter (that is, we resolve the
       // conflict in favor of parameters values that are different than
       // the current configuration).  If two or more historical values
       // differ from the current configuration, throw an exception.
       // Note that it is possible to give precendence to the current
       // configuration by disabling inheritance for that configuration
       // parameter.
 
       // Don't do anything if no parameters are supposed to be inherited.
 
       if(!fInheritNumberTimeSamples) 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.size() != 0) {
 
         TFile* file = (TFile*) new TFile(filename.c_str(), "READ");
         if(file != 0 && !file->IsZombie() && file->IsOpen()) {
 
           // Open the sqlite datatabase.
 
           ::art::SQLite3Wrapper sqliteDB(file, "RootFileDB");
 
           // Loop over all stored ParameterSets.
 
           unsigned int iNumberTimeSamples = 0;  // Combined value of NumberTimeSamples.
           unsigned int nNumberTimeSamples = 0;  // Number of NumberTimeSamples parameters seen.
 
           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);
             auto ps = fhicl::ParameterSet::make(reinterpret_cast<char const *>(sqlite3_column_text(stmt, 0)));
 
             // Is this a DetectorPropertiesService parameter set?
 
             bool psok = isDetectorPropertiesServiceStandardGAr(ps);
             if(psok) {
 
               // Check NumberTimeSamples
 
               //            if(fInheritNumberTimeSamples) {
               unsigned int newNumberTimeSamples = ps.get<unsigned int>("NumberTimeSamples");
 
               // Ignore parameter values that match the current configuration.
 
               if(newNumberTimeSamples != fPS.get<unsigned int>("NumberTimeSamples")) {
                 if(nNumberTimeSamples == 0)
                   iNumberTimeSamples = newNumberTimeSamples;
                 else if(newNumberTimeSamples != iNumberTimeSamples) {
                   throw cet::exception(__FUNCTION__)
                   << "Historical values of NumberTimeSamples do not agree: "
                   << iNumberTimeSamples << " " << newNumberTimeSamples << "\n" ;
                 }
                 ++nNumberTimeSamples;
                 //          }
               }
             }
           }
 
           // Done looping over parameter sets.
           // Now decide which parameters we will actually override.
 
           if(// fInheritNumberTimeSamples &&
              nNumberTimeSamples != 0 &&
              iNumberTimeSamples != fProp->NumberTimeSamples()) {
             MF_LOG_INFO("DetectorPropertiesServiceStandardGAr")
             << "Overriding configuration parameter NumberTimeSamples using historical value.\n"
             << "  Configured value:        " << fProp->NumberTimeSamples() << "\n"
             << "  Historical (used) value: " << iNumberTimeSamples;
 
             fProp->SetNumberTimeSamples(iNumberTimeSamples);
           }
         }
 
         // Close file.
         if(file != 0) {
           if(file->IsOpen())
             file->Close();
           delete file;
         }
       }
 
     }

void gar::detinfo::DetectorPropertiesServiceStandardGAr::preProcessEvent	(	::art::Event const &	evt,
		art::ScheduleContext
	)

Definition at line 65 of file DetectorPropertiesServiceStandardGAr_service.cc.

     {
       // Make sure TPC Clock is updated with TimeService (though in principle it shouldn't change
       fProp->UpdateClocks(gar::providerFrom<detinfo::DetectorClocksServiceGAr>());
     }

virtual const provider_type* gar::detinfo::DetectorPropertiesServiceStandardGAr::provider ( ) const

inlineoverridevirtual

Implements gar::detinfo::DetectorPropertiesService.

Definition at line 91 of file DetectorPropertiesServiceStandardGAr.h.

91 { return fProp.get();}

gar::detinfo::DetectorPropertiesServiceStandardGAr::fProp

std::unique_ptr< detinfo::DetectorPropertiesStandard > fProp

Definition: DetectorPropertiesServiceStandardGAr.h:95

void gar::detinfo::DetectorPropertiesServiceStandardGAr::reconfigure ( fhicl::ParameterSet const & pset )

overridevirtual

Implements gar::detinfo::DetectorPropertiesService.

Definition at line 54 of file DetectorPropertiesServiceStandardGAr_service.cc.

     {
       fProp->ValidateAndConfigure(p, { "InheritNumberTimeSamples" });
 
       // Save the parameter set.
       fPS = p;
 
       return;
     }