core::ProviderManager Class Reference

Interface to LArSoft services. More...

#include <ProviderManager.hh>

Public Member Functions
	ProviderManager (Experiment det, std::string fcl="", bool setup_event_services=true)
void	SetupServices (gallery::Event &ev)
const geo::GeometryCore *	GetGeometryProvider () const
const geo::AuxDetGeometryCore *	GetAuxDetGeometryProvider () const
const detinfo::LArPropertiesStandard *	GetLArPropertiesProvider () const
const detinfo::DetectorClocksStandard *	GetDetectorClocksProvider () const
const detinfo::DetectorPropertiesStandard *	GetDetectorPropertiesProvider () const
cheat::BackTracker *	GetBackTrackerProvider () const
cheat::ParticleInventory *	GetParticleInventoryProvider () const
cheat::PhotonBackTracker *	GetPhotonBackTrackerProvider () const

Static Public Member Functions
static std::vector< Experiment >	GetValidExperiments ()

Private Attributes
fhicl::ParameterSet *	config
std::unique_ptr < geo::GeometryCore >	fGeometryProvider
std::unique_ptr < geo::AuxDetGeometryCore >	fAuxDetGeometryProvider
std::unique_ptr < detinfo::LArPropertiesStandard >	fLArPropertiesProvider
std::unique_ptr < detinfo::DetectorClocksStandard >	fDetectorClocksProvider
std::unique_ptr < detinfo::DetectorPropertiesStandard >	fDetectorPropertiesProvider
std::unique_ptr < cheat::BackTracker >	fBackTrackerProvider
std::unique_ptr < cheat::ParticleInventory >	fParticleInventoryProvider
std::unique_ptr < cheat::PhotonBackTracker >	fPhotonBackTrackerProvider

Detailed Description

Interface to LArSoft services.

The ProviderManager handles loading and provides access to LArSoft services:

• Geometry
• LArProperties
• DetectorClocks
• DetectorProperties

Parameters

det	The detector ID (as defined in the Detector enum)
fcl	An optional FHiCL file for service settings

Definition at line 50 of file ProviderManager.hh.

Constructor & Destructor Documentation

core::ProviderManager::ProviderManager	(	Experiment	det,
		std::string	fcl = "",
		bool	setup_event_services = true
	)

Definition at line 30 of file ProviderManager.cxx.

                                                                                         {
  // Configuration look up policy: allow absolute paths, and search in the
  // $FHICL_FILE_PATH for non-absolute paths.
  const char* fhicl_file_path = getenv("FHICL_FILE_PATH");
  assert(fhicl_file_path);
  cet::filepath_lookup_nonabsolute policy(fhicl_file_path);

  fhicl::ParameterSet cfg;

  // Geometry: Load the correct geo::GeometryCore subclass for each detector
  switch (det) {
    case kExpSBND: {
      fcl = (fcl == "" ? "gallery_services_sbnd.fcl" : fcl);
      cfg = lar::standalone::ParseConfiguration(fcl, policy);
      fGeometryProvider = \
        lar::standalone::SetupGeometry<geo::ChannelMapSBNDAlg>(
          cfg.get<fhicl::ParameterSet>("services.Geometry"));
      }
      break;
    case kExpMicroBooNE: {
      fcl = (fcl == "" ? "gallery_services_uboone.fcl" : fcl);
      cfg = lar::standalone::ParseConfiguration(fcl, policy);
      fhicl::ParameterSet pset = \
        cfg.get<fhicl::ParameterSet>("services.Geometry");
      // For MicroBooNE, we also need to initialize the channel map with the
      // optical detector channel mapping
      std::unique_ptr<geo::ChannelMapAlg> channelMap = \
        std::make_unique<geo::ChannelMapUBooNEAlg>(
          cfg.get<fhicl::ParameterSet>("services.ExptGeoHelperInterface"), pset);
      fGeometryProvider = \
        lar::standalone::SetupGeometryWithChannelMapping(pset, std::move(channelMap));
      }
      break;
    case kExpICARUS: {
      fcl = (fcl == "" ? "gallery_services_icarus.fcl" : fcl);
      cfg = lar::standalone::ParseConfiguration(fcl, policy);
      fGeometryProvider = \
        lar::standalone::SetupGeometry<geo::ChannelMapIcarusAlg>(
          cfg.get<fhicl::ParameterSet>("services.Geometry"));
      }
      break;
    default:
      std::cerr << "ProviderManager: Unknown detector ID" << std::endl;
      assert(false);
      break;
  }
  config = new fhicl::ParameterSet(cfg);

  // AuxDetGeometry
  fAuxDetGeometryProvider = std::make_unique<geo::AuxDetGeometryCore>(cfg.get<fhicl::ParameterSet>("services.AuxDetGeometry"));

  // find the GDML and load it
  std::string relPath              = config->get<std::string>("services.AuxDetGeometry.RelativePath",     ""   );
  const std::string GDMLFileName   = config->get<std::string>("services.AuxDetGeometry.GDML"                   );

  cet::search_path sp("FW_SEARCH_PATH");

  std::string GDMLFilePathHint = relPath + GDMLFileName;
  std::string GDMLFilePath;
  if( !sp.find_file(GDMLFilePathHint, GDMLFilePath) ) {
    throw cet::exception("StaticLoadGeometry")
      << "Can't find geometry file '" << GDMLFilePathHint << std::endl;
  }

  std::string ROOTFilePathHint = relPath + GDMLFileName;
  std::string ROOTFilePath;
  if( !sp.find_file(ROOTFilePathHint, ROOTFilePath) ) {
    throw cet::exception("StaticLoadGeometry")
      << "Can't find geometry file '" << ROOTFilePathHint
      << "' (for geometry)!\n";
  }
  fAuxDetGeometryProvider->LoadGeometryFile(GDMLFilePath, ROOTFilePath);

  // LArProperties
  fLArPropertiesProvider = \
    testing::setupProvider<detinfo::LArPropertiesStandard>(
      cfg.get<fhicl::ParameterSet>("services.LArPropertiesService"));

  // DetectorClocks
  fDetectorClocksProvider = \
    testing::setupProvider<detinfo::DetectorClocksStandard>(
      cfg.get<fhicl::ParameterSet>("services.DetectorClocksService"));

  // DetectorProperties
  fDetectorPropertiesProvider = \
    testing::setupProvider<detinfo::DetectorPropertiesStandard>(
      cfg.get<fhicl::ParameterSet>("services.DetectorPropertiesService"),
      detinfo::DetectorPropertiesStandard::providers_type {
        fGeometryProvider.get(),
        static_cast<const detinfo::LArProperties*>(fLArPropertiesProvider.get()),
        static_cast<const detinfo::DetectorClocks*>(fDetectorClocksProvider.get())
      });

  fParticleInventoryProvider = NULL;
  fBackTrackerProvider = NULL;
  fPhotonBackTrackerProvider = NULL;
  if (!setup_event_services) {
    return;
  }

  // ParticleInventory
  if (cfg.has_key("services.ParticleInventoryService")) {
    fParticleInventoryProvider = testing::setupProvider<cheat::ParticleInventory>(
       cfg.get<fhicl::ParameterSet>("services.ParticleInventoryService"));
  }
  else {
    std::cerr << "Warning: Particle inventory service is missing from fhicl config (" << fcl << ")." \
      << " Setting ParticleInventoryService to NULL" << std::endl;
  }

  // BackTracker
  if (cfg.has_key("services.BackTrackerService")) {
    fBackTrackerProvider = \
      testing::setupProvider<cheat::BackTracker>(
        cfg.get<fhicl::ParameterSet>("services.BackTrackerService"),
        fParticleInventoryProvider.get(), fGeometryProvider.get(),
        fDetectorClocksProvider.get());
  }
  else {
    std::cerr << "Warning: BackTracker service is missing from fhicl config (" << fcl << ")." \
      << " Setting BackTrackerService to NULL" << std::endl;
  }

  // Photon BackTracker
  if (cfg.has_key("services.PhotonBackTrackerService")) {
    fPhotonBackTrackerProvider = \
      testing::setupProvider<cheat::PhotonBackTracker>(
        cfg.get<fhicl::ParameterSet>("services.PhotonBackTrackerService"),
        fParticleInventoryProvider.get(), fGeometryProvider.get());
  }
  else {
    std::cerr << "Warning: PhotonBackTracker service is missing from fhicl config (" << fcl <<")." \
     << " Setting PhotonBackTrackerService to NULL" << std::endl;
  }

  std::cout << "ProviderManager: Loaded configuration for: "
            << fGeometryProvider.get()->DetectorName() << std::endl;
}

Member Function Documentation

const geo::AuxDetGeometryCore* core::ProviderManager::GetAuxDetGeometryProvider ( ) const

inline

Definition at line 60 of file ProviderManager.hh.

                                                                 {
    return fAuxDetGeometryProvider.get();
  }

cheat::BackTracker* core::ProviderManager::GetBackTrackerProvider ( ) const

inline

Definition at line 76 of file ProviderManager.hh.

                                                   {
    return fBackTrackerProvider.get();
  }

const detinfo::DetectorClocksStandard* core::ProviderManager::GetDetectorClocksProvider ( ) const

inline

Definition at line 68 of file ProviderManager.hh.

                                                                         {
    return fDetectorClocksProvider.get();
  }

const detinfo::DetectorPropertiesStandard* core::ProviderManager::GetDetectorPropertiesProvider ( ) const

inline

Definition at line 72 of file ProviderManager.hh.

                                                                                 {
    return fDetectorPropertiesProvider.get();
  }

const geo::GeometryCore* core::ProviderManager::GetGeometryProvider ( ) const

inline

Definition at line 56 of file ProviderManager.hh.

                                                     {
    return fGeometryProvider.get();
  }

const detinfo::LArPropertiesStandard* core::ProviderManager::GetLArPropertiesProvider ( ) const

inline

Definition at line 64 of file ProviderManager.hh.

                                                                       {
    return fLArPropertiesProvider.get();
  }

cheat::ParticleInventory* core::ProviderManager::GetParticleInventoryProvider ( ) const

inline

Definition at line 80 of file ProviderManager.hh.

                                                               {
    return fParticleInventoryProvider.get();
  }

cheat::PhotonBackTracker* core::ProviderManager::GetPhotonBackTrackerProvider ( ) const

inline

Definition at line 84 of file ProviderManager.hh.

                                                               {
    return fPhotonBackTrackerProvider.get();
  }

std::vector< Experiment > core::ProviderManager::GetValidExperiments ( )

static

Definition at line 193 of file ProviderManager.cxx.

                                                           {
  static std::vector<Experiment> ex = {
    kExpSBND, kExpMicroBooNE, kExpICARUS
  };
  return ex;
}

void core::ProviderManager::SetupServices

(

gallery::Event &

ev

)

Definition at line 169 of file ProviderManager.cxx.

                                                    {
  // reset the channels of the back tracker
  if (GetBackTrackerProvider() != NULL) {
    GetBackTrackerProvider()->ClearEvent();
    GetBackTrackerProvider()->PrepSimChannels(ev);
  }

  // reset information in particle inventory
  if (GetParticleInventoryProvider() != NULL) {
    GetParticleInventoryProvider()->ClearEvent();
    GetParticleInventoryProvider()->PrepParticleList(ev);
    GetParticleInventoryProvider()->PrepMCTruthList(ev);
    GetParticleInventoryProvider()->PrepTrackIdToMCTruthIndex(ev);
  }

  // reset information in the photon back tracker
  if (GetPhotonBackTrackerProvider() != NULL) {
    GetPhotonBackTrackerProvider()->ClearEvent();
    GetPhotonBackTrackerProvider()->PrepOpDetBTRs(ev);
    // GetPhotonBackTrackerProvider()->PrepOpFlashToOpHits(ev);
  }
}

Member Data Documentation

fhicl::ParameterSet* core::ProviderManager::config

private

Definition at line 91 of file ProviderManager.hh.

std::unique_ptr<geo::AuxDetGeometryCore> core::ProviderManager::fAuxDetGeometryProvider

private

Definition at line 93 of file ProviderManager.hh.

std::unique_ptr<cheat::BackTracker> core::ProviderManager::fBackTrackerProvider

private

Definition at line 97 of file ProviderManager.hh.

std::unique_ptr<detinfo::DetectorClocksStandard> core::ProviderManager::fDetectorClocksProvider

private

Definition at line 95 of file ProviderManager.hh.

std::unique_ptr<detinfo::DetectorPropertiesStandard> core::ProviderManager::fDetectorPropertiesProvider

private

Definition at line 96 of file ProviderManager.hh.

std::unique_ptr<geo::GeometryCore> core::ProviderManager::fGeometryProvider

private

Definition at line 92 of file ProviderManager.hh.

std::unique_ptr<detinfo::LArPropertiesStandard> core::ProviderManager::fLArPropertiesProvider

private

Definition at line 94 of file ProviderManager.hh.

std::unique_ptr<cheat::ParticleInventory> core::ProviderManager::fParticleInventoryProvider

private

Definition at line 98 of file ProviderManager.hh.

std::unique_ptr<cheat::PhotonBackTracker> core::ProviderManager::fPhotonBackTrackerProvider

private

Definition at line 99 of file ProviderManager.hh.

---

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

• ProviderManager.hh
• ProviderManager.cxx