Inheritance diagram for phot::PDFastSimPAR:

Classes
struct	Config

Public Types
using	Parameters = art::EDProducer::Table< Config >

using	ModuleType = EDProducer

template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >

Public Member Functions
	PDFastSimPAR (Parameters const &config)

void	produce (art::Event &) override

void	doBeginJob (SharedResources const &resources)

void	doEndJob ()

void	doRespondToOpenInputFile (FileBlock const &fb)

void	doRespondToCloseInputFile (FileBlock const &fb)

void	doRespondToOpenOutputFiles (FileBlock const &fb)

void	doRespondToCloseOutputFiles (FileBlock const &fb)

bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)

void	fillProductDescriptions ()

void	registerProducts (ProductDescriptions &productsToRegister)

ModuleDescription const &	moduleDescription () const

void	setModuleDescription (ModuleDescription const &)

std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const

void	sortConsumables (std::string const &current_process_name)

std::unique_ptr< Worker >	makeWorker (WorkerParams const &wp)

template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)

template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Protected Member Functions
ConsumesCollector &	consumesCollector ()

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Private Member Functions
void	detectedNumPhotons (std::vector< int > &DetectedNumPhotons, const std::vector< double > &OpDetVisibilities, const int NumPhotons) const

void	AddOpDetBTR (std::vector< sim::OpDetBacktrackerRecord > &opbtr, std::vector< int > &ChannelMap, const sim::OpDetBacktrackerRecord &btr) const

bool	isOpDetInSameTPC (geo::Point_t const &ScintPoint, geo::Point_t const &OpDetPoint) const

std::vector< geo::Point_t >	opDetCenters () const

Private Attributes
std::unique_ptr< SemiAnalyticalModel >	fVisibilityModel

std::unique_ptr< PropagationTimeModel >	fPropTimeModel

CLHEP::HepRandomEngine &	fPhotonEngine

std::unique_ptr< CLHEP::RandPoissonQ >	fRandPoissPhot

CLHEP::HepRandomEngine &	fScintTimeEngine

std::unique_ptr< ScintTime >	fScintTime

geo::GeometryCore const &	fGeom

larg4::ISTPC	fISTPC

const size_t	fNOpChannels

const std::vector< geo::BoxBoundedGeo >	fActiveVolumes

const int	fNTPC

const std::vector< geo::Point_t >	fOpDetCenter

const art::InputTag	fSimTag

const bool	fDoFastComponent

const bool	fDoSlowComponent

const bool	fDoReflectedLight

const bool	fIncludeAnodeReflections

const bool	fIncludePropTime

const bool	fGeoPropTimeOnly

const bool	fUseLitePhotons

const bool	fOpaqueCathode

const bool	fOnlyActiveVolume

const bool	fOnlyOneCryostat

const bool	fUseXeAbsorption

Detailed Description

Definition at line 77 of file PDFastSimPAR_module.cc.

Member Typedef Documentation

using art::EDProducer::ModuleType = EDProducer

inherited

Definition at line 17 of file EDProducer.h.

using phot::PDFastSimPAR::Parameters = art::EDProducer::Table<Config>

Definition at line 129 of file PDFastSimPAR_module.cc.

template<typename UserConfig , typename KeysToIgnore = void>

using art::detail::Producer::Table = Modifier::Table<UserConfig, KeysToIgnore>

inherited

Definition at line 26 of file Producer.h.

Constructor & Destructor Documentation

phot::PDFastSimPAR::PDFastSimPAR ( Parameters const & config )

explicit

Definition at line 182 of file PDFastSimPAR_module.cc.

References art::errors::Configuration, art::detail::EngineCreator::createEngine(), util::enumerate(), larg4::ISTPC::extractActiveLArVolume(), fActiveVolumes, fDoFastComponent, fDoReflectedLight, fDoSlowComponent, fGeom, fGeoPropTimeOnly, fIncludeAnodeReflections, fIncludePropTime, fISTPC, fNOpChannels, fNTPC, fOnlyActiveVolume, fOnlyOneCryostat, fOpaqueCathode, fOpDetCenter, fPhotonEngine, fPropTimeModel, fRandPoissPhot, fScintTime, fScintTimeEngine, fSimTag, fUseLitePhotons, fUseXeAbsorption, fVisibilityModel, fhicl::ParameterSet::get(), geo::GeometryCore::Ncryostats(), geo::GeometryCore::NOpDets(), geo::GeometryCore::NTPC(), and opDetCenters().

     : art::EDProducer{config}
     , fPhotonEngine(art::ServiceHandle<rndm::NuRandomService>()->registerAndSeedEngine(
         createEngine(0, "HepJamesRandom", "photon"),
         "HepJamesRandom",
         "photon",
         config.get_PSet(),
         "SeedPhoton"))
     , fRandPoissPhot(std::make_unique<CLHEP::RandPoissonQ>(fPhotonEngine))
     , fScintTimeEngine(art::ServiceHandle<rndm::NuRandomService>()->registerAndSeedEngine(
         createEngine(0, "HepJamesRandom", "scinttime"),
         "HepJamesRandom",
         "scinttime",
         config.get_PSet(),
         "SeedScintTime"))
     , fScintTime{art::make_tool<phot::ScintTime>(config().ScintTimeTool.get<fhicl::ParameterSet>())}
     , fGeom(*(lar::providerFrom<geo::Geometry>()))
     , fISTPC{fGeom}
     , fNOpChannels(fGeom.NOpDets())
     , fActiveVolumes(fISTPC.extractActiveLArVolume(fGeom))
     , fNTPC(fGeom.NTPC())
     , fOpDetCenter(opDetCenters())
     , fSimTag(config().SimulationLabel())
     , fDoFastComponent(config().DoFastComponent())
     , fDoSlowComponent(config().DoSlowComponent())
     , fDoReflectedLight(config().DoReflectedLight())
     , fIncludeAnodeReflections(config().IncludeAnodeReflections())
     , fIncludePropTime(config().IncludePropTime())
     , fGeoPropTimeOnly(config().GeoPropTimeOnly())
     , fUseLitePhotons(config().UseLitePhotons())
     , fOpaqueCathode(config().OpaqueCathode())
     , fOnlyActiveVolume(config().OnlyActiveVolume())
     , fOnlyOneCryostat(config().OnlyOneCryostat())
     , fUseXeAbsorption(config().UseXeAbsorption())
   {
     mf::LogInfo("PDFastSimPAR") << "Initializing PDFastSimPAR." << std::endl;
 
     // Parameterized Simulation
     fhicl::ParameterSet VUVHitsParams = config().VUVHits.get<fhicl::ParameterSet>();
     fhicl::ParameterSet VUVTimingParams;
     fhicl::ParameterSet VISHitsParams;
     fhicl::ParameterSet VISTimingParams;
 
     // Validate configuration options
     if (fIncludePropTime &&
         !config().VUVTiming.get_if_present<fhicl::ParameterSet>(VUVTimingParams)) {
       throw art::Exception(art::errors::Configuration)
         << "Propagation time simulation requested, but VUVTiming not specified."
         << "\n";
     }
     if ((fDoReflectedLight || fIncludeAnodeReflections) &&
         !config().VISHits.get_if_present<fhicl::ParameterSet>(VISHitsParams)) {
       throw art::Exception(art::errors::Configuration)
         << "Reflected light or anode reflections simulation requested, but VisHits not specified."
         << "\n";
     }
     if (fDoReflectedLight && fIncludePropTime &&
         !config().VISTiming.get_if_present<fhicl::ParameterSet>(VISTimingParams)) {
       throw art::Exception(art::errors::Configuration)
         << "Reflected light propagation time simulation requested, but VISTiming not specified."
         << "\n";
     }
     if (fGeom.Ncryostats() > 1U) {
       if (fOnlyOneCryostat) {
         mf::LogWarning("PDFastSimPAR")
           << std::string(80, '=') << "\nA detector with " << fGeom.Ncryostats()
           << " cryostats is configured"
           << " , and semi-analytic model is requested for scintillation photon propagation."
           << " THIS CONFIGURATION IS NOT SUPPORTED and it is open to bugs"
           << " (e.g. scintillation may be detected only in cryostat #0)."
           << "\nThis would be normally a fatal error, but it has been forcibly overridden."
           << "\n"
           << std::string(80, '=');
       }
       else {
         throw art::Exception(art::errors::Configuration)
           << "Photon propagation via semi-analytic model is not supported yet"
           << " on detectors with more than one cryostat.";
       }
     }
 
     // Initialise the Scintillation Time
     fScintTime->initRand(fScintTimeEngine);
 
     // photo-detector visibility model (semi-analytical model)
     fVisibilityModel = std::make_unique<SemiAnalyticalModel>(
       VUVHitsParams, VISHitsParams, fDoReflectedLight, fIncludeAnodeReflections, fUseXeAbsorption);
 
     // propagation time model
     if (fIncludePropTime)
       fPropTimeModel = std::make_unique<PropagationTimeModel>(
         VUVTimingParams, VISTimingParams, fScintTimeEngine, fDoReflectedLight, fGeoPropTimeOnly);
 
     {
       auto log = mf::LogTrace("PDFastSimPAR") << "PDFastSimPAR: active volume boundaries from "
                                               << fActiveVolumes.size() << " volumes:";
       for (auto const& [iCryo, box] : util::enumerate(fActiveVolumes)) {
         log << "\n - C:" << iCryo << ": " << box.Min() << " -- " << box.Max() << " cm";
       }
     }
 
     if (fUseLitePhotons) {
       mf::LogInfo("PDFastSimPAR") << "Using Lite Photons";
       produces<std::vector<sim::SimPhotonsLite>>();
       produces<std::vector<sim::OpDetBacktrackerRecord>>();
       if (fDoReflectedLight) {
         mf::LogInfo("PDFastSimPAR") << "Storing Reflected Photons";
         produces<std::vector<sim::SimPhotonsLite>>("Reflected");
         produces<std::vector<sim::OpDetBacktrackerRecord>>("Reflected");
       }
     }
     else {
       mf::LogInfo("PDFastSimPAR") << "Using Sim Photons";
       produces<std::vector<sim::SimPhotons>>();
       if (fDoReflectedLight) {
         mf::LogInfo("PDFastSimPAR") << "Storing Reflected Photons";
         produces<std::vector<sim::SimPhotons>>("Reflected");
       }
     }
     mf::LogInfo("PDFastSimPAR") << "PDFastSimPAR Initialization finish.\n"
                                 << "Simulate using semi-analytic model for number of hits."
                                 << std::endl;
   }

Member Function Documentation

void phot::PDFastSimPAR::AddOpDetBTR	(	std::vector< sim::OpDetBacktrackerRecord > &	opbtr,
		std::vector< int > &	ChannelMap,
		const sim::OpDetBacktrackerRecord &	btr
	)		const

private

Definition at line 543 of file PDFastSimPAR_module.cc.

References sim::OpDetBacktrackerRecord::OpDetNum(), and sim::OpDetBacktrackerRecord::timePDclockSDPsMap().

Referenced by produce().

   {
     int iChan = btr.OpDetNum();
     if (ChannelMap[iChan] < 0) {
       ChannelMap[iChan] = opbtr.size();
       opbtr.emplace_back(std::move(btr));
     }
     else {
       size_t idtest = ChannelMap[iChan];
       auto const& timePDclockSDPsMap = btr.timePDclockSDPsMap();
       for (auto const& timePDclockSDP : timePDclockSDPsMap) {
         for (auto const& sdp : timePDclockSDP.second) {
           double xyz[3] = {sdp.x, sdp.y, sdp.z};
           opbtr.at(idtest).AddScintillationPhotons(
             sdp.trackID, timePDclockSDP.first, sdp.numPhotons, xyz, sdp.energy);
         }
       }
     }
   }

template<typename T , BranchType BT>

ProductToken< T > art::ModuleBase::consumes ( InputTag const & tag )

protectedinherited

Definition at line 61 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumes().

   {
     return collector_.consumes<T, BT>(tag);
   }

ConsumesCollector & art::ModuleBase::consumesCollector ( )

protectedinherited

Definition at line 57 of file ModuleBase.cc.

References art::ModuleBase::collector_.

   {
     return collector_;
   }

template<typename T , BranchType BT>

void art::ModuleBase::consumesMany ( )

protectedinherited

Definition at line 75 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumesMany().

   {
     collector_.consumesMany<T, BT>();
   }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::ModuleBase::consumesView ( InputTag const & )

protectedinherited

template<typename T , BranchType BT>

ViewToken<T> art::ModuleBase::consumesView ( InputTag const & tag )

inherited

Definition at line 68 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumesView().

   {
     return collector_.consumesView<T, BT>(tag);
   }

void phot::PDFastSimPAR::detectedNumPhotons	(	std::vector< int > &	DetectedNumPhotons,
		const std::vector< double > &	OpDetVisibilities,
		const int	NumPhotons
	)		const

private

Definition at line 567 of file PDFastSimPAR_module.cc.

References fRandPoissPhot.

Referenced by produce().

   {
     for (size_t i = 0; i < OpDetVisibilities.size(); ++i) {
       DetectedNumPhotons[i] = fRandPoissPhot->fire(OpDetVisibilities[i] * NumPhotons);
     }
   }

void art::detail::Producer::doBeginJob ( SharedResources const & resources )

inherited

Definition at line 22 of file Producer.cc.

References art::detail::Producer::beginJobWithFrame(), and art::detail::Producer::setupQueues().

   {
     setupQueues(resources);
     ProcessingFrame const frame{ScheduleID{}};
     beginJobWithFrame(frame);
   }

bool art::detail::Producer::doBeginRun	(	RunPrincipal &	rp,
		ModuleContext const &	mc
	)

inherited

Definition at line 65 of file Producer.cc.

References art::detail::Producer::beginRunWithFrame(), art::RangeSet::forRun(), art::RunPrincipal::makeRun(), r, art::RunPrincipal::runID(), and art::ModuleContext::scheduleID().

   {
     auto r = rp.makeRun(mc, RangeSet::forRun(rp.runID()));
     ProcessingFrame const frame{mc.scheduleID()};
     beginRunWithFrame(r, frame);
     r.commitProducts();
     return true;
   }

bool art::detail::Producer::doBeginSubRun	(	SubRunPrincipal &	srp,
		ModuleContext const &	mc
	)

inherited

Definition at line 85 of file Producer.cc.

References art::detail::Producer::beginSubRunWithFrame(), art::RangeSet::forSubRun(), art::SubRunPrincipal::makeSubRun(), art::ModuleContext::scheduleID(), and art::SubRunPrincipal::subRunID().

   {
     auto sr = srp.makeSubRun(mc, RangeSet::forSubRun(srp.subRunID()));
     ProcessingFrame const frame{mc.scheduleID()};
     beginSubRunWithFrame(sr, frame);
     sr.commitProducts();
     return true;
   }

void art::detail::Producer::doEndJob ( )

inherited

Definition at line 30 of file Producer.cc.

References art::detail::Producer::endJobWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     endJobWithFrame(frame);
   }

bool art::detail::Producer::doEndRun	(	RunPrincipal &	rp,
		ModuleContext const &	mc
	)

inherited

Definition at line 75 of file Producer.cc.

References art::detail::Producer::endRunWithFrame(), art::RunPrincipal::makeRun(), r, art::ModuleContext::scheduleID(), and art::Principal::seenRanges().

   {
     auto r = rp.makeRun(mc, rp.seenRanges());
     ProcessingFrame const frame{mc.scheduleID()};
     endRunWithFrame(r, frame);
     r.commitProducts();
     return true;
   }

bool art::detail::Producer::doEndSubRun	(	SubRunPrincipal &	srp,
		ModuleContext const &	mc
	)

inherited

Definition at line 95 of file Producer.cc.

References art::detail::Producer::endSubRunWithFrame(), art::SubRunPrincipal::makeSubRun(), art::ModuleContext::scheduleID(), and art::Principal::seenRanges().

   {
     auto sr = srp.makeSubRun(mc, srp.seenRanges());
     ProcessingFrame const frame{mc.scheduleID()};
     endSubRunWithFrame(sr, frame);
     sr.commitProducts();
     return true;
   }

bool art::detail::Producer::doEvent	(	EventPrincipal &	ep,
		ModuleContext const &	mc,
		std::atomic< std::size_t > &	counts_run,
		std::atomic< std::size_t > &	counts_passed,
		std::atomic< std::size_t > &	counts_failed
	)

inherited

Definition at line 105 of file Producer.cc.

References art::detail::Producer::checkPutProducts_, e, art::EventPrincipal::makeEvent(), art::detail::Producer::produceWithFrame(), and art::ModuleContext::scheduleID().

   {
     auto e = ep.makeEvent(mc);
     ++counts_run;
     ProcessingFrame const frame{mc.scheduleID()};
     produceWithFrame(e, frame);
     e.commitProducts(checkPutProducts_, &expectedProducts<InEvent>());
     ++counts_passed;
     return true;
   }

void art::detail::Producer::doRespondToCloseInputFile ( FileBlock const & fb )

inherited

Definition at line 44 of file Producer.cc.

References art::detail::Producer::respondToCloseInputFileWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToCloseInputFileWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToCloseOutputFiles ( FileBlock const & fb )

inherited

Definition at line 58 of file Producer.cc.

References art::detail::Producer::respondToCloseOutputFilesWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToCloseOutputFilesWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToOpenInputFile ( FileBlock const & fb )

inherited

Definition at line 37 of file Producer.cc.

References art::detail::Producer::respondToOpenInputFileWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToOpenInputFileWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToOpenOutputFiles ( FileBlock const & fb )

inherited

Definition at line 51 of file Producer.cc.

References art::detail::Producer::respondToOpenOutputFilesWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToOpenOutputFilesWithFrame(fb, frame);
   }

void art::Modifier::fillProductDescriptions ( )

inherited

Definition at line 10 of file Modifier.cc.

References art::ProductRegistryHelper::fillDescriptions(), and art::ModuleBase::moduleDescription().

   {
     ProductRegistryHelper::fillDescriptions(moduleDescription());
   }

std::array< std::vector< ProductInfo >, NumBranchTypes > const & art::ModuleBase::getConsumables ( ) const

inherited

Definition at line 43 of file ModuleBase.cc.

References art::ModuleBase::collector_, and art::ConsumesCollector::getConsumables().

   {
     return collector_.getConsumables();
   }

bool phot::PDFastSimPAR::isOpDetInSameTPC	(	geo::Point_t const &	ScintPoint,
		geo::Point_t const &	OpDetPoint
	)		const

private

Definition at line 578 of file PDFastSimPAR_module.cc.

References util::abs(), and fNTPC.

Referenced by produce().

   {
     // check optical channel is in same TPC as scintillation light, if not doesn't see light
     // temporary method working for SBND, uBooNE, DUNE 1x2x6; to be replaced to work in full DUNE geometry
     // check x coordinate has same sign or is close to zero
     if (((ScintPoint.X() < 0.) != (OpDetPoint.X() < 0.)) && std::abs(OpDetPoint.X()) > 10. &&
         fNTPC == 2) { // TODO: replace with geometry service method
       return false;
     }
     return true;
   }

std::unique_ptr< Worker > art::ModuleBase::makeWorker ( WorkerParams const & wp )

inherited

Definition at line 37 of file ModuleBase.cc.

References art::ModuleBase::doMakeWorker(), and art::NumBranchTypes.

   {
     return doMakeWorker(wp);
   }

template<typename T , BranchType BT>

ProductToken< T > art::ModuleBase::mayConsume ( InputTag const & tag )

protectedinherited

Definition at line 82 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsume().

   {
     return collector_.mayConsume<T, BT>(tag);
   }

template<typename T , BranchType BT>

void art::ModuleBase::mayConsumeMany ( )

protectedinherited

Definition at line 96 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsumeMany().

   {
     collector_.mayConsumeMany<T, BT>();
   }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::ModuleBase::mayConsumeView ( InputTag const & )

protectedinherited

template<typename T , BranchType BT>

ViewToken<T> art::ModuleBase::mayConsumeView ( InputTag const & tag )

inherited

Definition at line 89 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsumeView().

   {
     return collector_.mayConsumeView<T, BT>(tag);
   }

ModuleDescription const & art::ModuleBase::moduleDescription ( ) const

inherited

Definition at line 13 of file ModuleBase.cc.

References art::errors::LogicError.

Referenced by art::OutputModule::doRespondToOpenInputFile(), art::OutputModule::doWriteEvent(), art::Modifier::fillProductDescriptions(), art::OutputModule::makePlugins_(), art::OutputWorker::OutputWorker(), reco::shower::LArPandoraModularShowerCreation::produce(), art::Modifier::registerProducts(), and art::OutputModule::registerProducts().

   {
     if (md_.has_value()) {
       return *md_;
     }
 
     throw Exception{errors::LogicError,
                     "There was an error while calling moduleDescription().\n"}
       << "The moduleDescription() base-class member function cannot be called\n"
          "during module construction.  To determine which module is "
          "responsible\n"
          "for calling it, find the '<module type>:<module "
          "label>@Construction'\n"
          "tag in the message prefix above.  Please contact artists@fnal.gov\n"
          "for guidance.\n";
   }

std::vector< geo::Point_t > phot::PDFastSimPAR::opDetCenters ( ) const

private

Definition at line 591 of file PDFastSimPAR_module.cc.

References util::counter(), DEFINE_ART_MODULE, fGeom, fNOpChannels, geo::OpDetGeo::GetCenter(), and geo::GeometryCore::OpDetGeoFromOpDet().

Referenced by PDFastSimPAR().

   {
     std::vector<geo::Point_t> opDetCenter;
     for (size_t const i : util::counter(fNOpChannels)) {
       geo::OpDetGeo const& opDet = fGeom.OpDetGeoFromOpDet(i);
       opDetCenter.push_back(opDet.GetCenter());
     }
     return opDetCenter;
   }

void phot::PDFastSimPAR::produce ( art::Event & event )

overridevirtual

Implements art::EDProducer.

Definition at line 307 of file PDFastSimPAR_module.cc.

References AddOpDetBTR(), sim::OpDetBacktrackerRecord::AddScintillationPhotons(), detectedNumPhotons(), util::end(), sim::OnePhoton::Energy, fDoFastComponent, fDoReflectedLight, fDoSlowComponent, fIncludeAnodeReflections, fIncludePropTime, fISTPC, fNOpChannels, fOnlyActiveVolume, fOpaqueCathode, fOpDetCenter, fPropTimeModel, fScintTime, fSimTag, fUseLitePhotons, fVisibilityModel, art::ProductRetriever::getByLabel(), sim::OnePhoton::InitialPosition, isOpDetInSameTPC(), larg4::ISTPC::isScintInActiveVolume(), sim::OnePhoton::MotherTrackID, n, sim::OnePhoton::SetInSD, and sim::OnePhoton::Time.

   {
     mf::LogTrace("PDFastSimPAR") << "PDFastSimPAR Module Producer"
                                  << "EventID: " << event.event();
 
     std::vector<int> PDChannelToSOCMapDirect(fNOpChannels, -1);  // Where each OpChan is.
     std::vector<int> PDChannelToSOCMapReflect(fNOpChannels, -1); // Where each OpChan is.
 
     // SimPhotonsLite
     auto phlit = std::make_unique<std::vector<sim::SimPhotonsLite>>();
     auto opbtr = std::make_unique<std::vector<sim::OpDetBacktrackerRecord>>();
     auto phlit_ref = std::make_unique<std::vector<sim::SimPhotonsLite>>();
     auto opbtr_ref = std::make_unique<std::vector<sim::OpDetBacktrackerRecord>>();
     auto& dir_phlitcol(*phlit);
     auto& ref_phlitcol(*phlit_ref);
     // SimPhotons
     auto phot = std::make_unique<std::vector<sim::SimPhotons>>();
     auto phot_ref = std::make_unique<std::vector<sim::SimPhotons>>();
     auto& dir_photcol(*phot);
     auto& ref_photcol(*phot_ref);
     if (fUseLitePhotons) {
       dir_phlitcol.resize(fNOpChannels);
       ref_phlitcol.resize(fNOpChannels);
       for (unsigned int i = 0; i < fNOpChannels; i++) {
         dir_phlitcol[i].OpChannel = i;
         ref_phlitcol[i].OpChannel = i;
       }
     }
     else { // SimPhotons
       dir_photcol.resize(fNOpChannels);
       ref_photcol.resize(fNOpChannels);
       for (unsigned int i = 0; i < fNOpChannels; i++) {
         dir_photcol[i].fOpChannel = i;
         ref_photcol[i].fOpChannel = i;
       }
     }
 
     art::Handle<std::vector<sim::SimEnergyDeposit>> edepHandle;
     if (!event.getByLabel(fSimTag, edepHandle)) {
       mf::LogError("PDFastSimPAR") << "PDFastSimPAR Module Cannot getByLabel: " << fSimTag;
       return;
     }
 
     auto const& edeps = edepHandle;
 
     int num_points = 0;
     int num_fastph = 0;
     int num_slowph = 0;
     int num_fastdp = 0;
     int num_slowdp = 0;
 
     for (auto const& edepi : *edeps) {
       num_points++;
 
       int nphot_fast = edepi.NumFPhotons();
       int nphot_slow = edepi.NumSPhotons();
 
       num_fastph += nphot_fast;
       num_slowph += nphot_slow;
 
       if (!((nphot_fast > 0 && fDoFastComponent) || (nphot_slow > 0 && fDoSlowComponent))) continue;
 
       int trackID = edepi.TrackID();
       int nphot = edepi.NumPhotons();
       double edeposit = edepi.Energy() / nphot;
       double pos[3] = {edepi.MidPointX(), edepi.MidPointY(), edepi.MidPointZ()};
       geo::Point_t const ScintPoint = {pos[0], pos[1], pos[2]};
 
       if (fOnlyActiveVolume && !fISTPC.isScintInActiveVolume(ScintPoint)) continue;
 
       // direct light
       std::vector<int> DetectedNumFast(fNOpChannels);
       std::vector<int> DetectedNumSlow(fNOpChannels);
 
       std::vector<double> OpDetVisibilities;
       fVisibilityModel->detectedDirectVisibilities(OpDetVisibilities, ScintPoint);
       detectedNumPhotons(DetectedNumFast, OpDetVisibilities, nphot_fast);
       detectedNumPhotons(DetectedNumSlow, OpDetVisibilities, nphot_slow);
 
       if (fIncludeAnodeReflections) {
         std::vector<int> AnodeDetectedNumFast(fNOpChannels);
         std::vector<int> AnodeDetectedNumSlow(fNOpChannels);
 
         std::vector<double> OpDetVisibilitiesAnode;
         fVisibilityModel->detectedReflectedVisibilities(OpDetVisibilitiesAnode, ScintPoint, true);
         detectedNumPhotons(AnodeDetectedNumFast, OpDetVisibilitiesAnode, nphot_fast);
         detectedNumPhotons(AnodeDetectedNumSlow, OpDetVisibilitiesAnode, nphot_slow);
 
         // add to existing count
         for (size_t i = 0; i < AnodeDetectedNumFast.size(); ++i) {
           DetectedNumFast[i] += AnodeDetectedNumFast[i];
         }
         for (size_t i = 0; i < AnodeDetectedNumSlow.size(); ++i) {
           DetectedNumSlow[i] += AnodeDetectedNumSlow[i];
         }
       }
 
       // reflected light, if enabled
       std::vector<int> ReflDetectedNumFast(fNOpChannels);
       std::vector<int> ReflDetectedNumSlow(fNOpChannels);
       if (fDoReflectedLight) {
         std::vector<double> OpDetVisibilitiesRefl;
         fVisibilityModel->detectedReflectedVisibilities(OpDetVisibilitiesRefl, ScintPoint, false);
         detectedNumPhotons(ReflDetectedNumFast, OpDetVisibilitiesRefl, nphot_fast);
         detectedNumPhotons(ReflDetectedNumSlow, OpDetVisibilitiesRefl, nphot_slow);
       }
 
       // loop through direct photons then reflected photons cases
       size_t DoReflected = (fDoReflectedLight) ? 1 : 0;
       for (size_t Reflected = 0; Reflected <= DoReflected; ++Reflected) {
         for (size_t channel = 0; channel < fNOpChannels; channel++) {
 
           if (fOpaqueCathode && !isOpDetInSameTPC(ScintPoint, fOpDetCenter[channel])) continue;
 
           int ndetected_fast = DetectedNumFast[channel];
           int ndetected_slow = DetectedNumSlow[channel];
           if (Reflected) {
             ndetected_fast = ReflDetectedNumFast[channel];
             ndetected_slow = ReflDetectedNumSlow[channel];
           }
           if (!((ndetected_fast > 0 && fDoFastComponent) ||
                 (ndetected_slow > 0 && fDoSlowComponent)))
             continue;
 
           // calculate propagation time, does not matter whether fast or slow photon
           std::vector<double> transport_time;
           if (fIncludePropTime) {
             transport_time.resize(ndetected_fast + ndetected_slow);
             fPropTimeModel->propagationTime(transport_time, ScintPoint, channel, Reflected);
           }
 
           // SimPhotonsLite case
           if (fUseLitePhotons) {
             sim::OpDetBacktrackerRecord tmpbtr(channel);
             if (ndetected_fast > 0 && fDoFastComponent) {
               int n = ndetected_fast;
               num_fastdp += n;
               for (int i = 0; i < n; ++i) {
                 // calculates the time at which the photon was produced
                 double dtime = edepi.StartT() + fScintTime->fastScintTime();
                 if (fIncludePropTime) dtime += transport_time[i];
                 int time = static_cast<int>(std::round(dtime));
                 if (Reflected)
                   ++ref_phlitcol[channel].DetectedPhotons[time];
                 else
                   ++dir_phlitcol[channel].DetectedPhotons[time];
                 tmpbtr.AddScintillationPhotons(trackID, time, 1, pos, edeposit);
               }
             }
             if (ndetected_slow > 0 && fDoSlowComponent) {
               int n = ndetected_slow;
               num_slowdp += n;
               for (int i = 0; i < n; ++i) {
                 double dtime = edepi.StartT() + fScintTime->slowScintTime();
                 if (fIncludePropTime) dtime += transport_time[ndetected_fast + i];
                 int time = static_cast<int>(std::round(dtime));
                 if (Reflected)
                   ++ref_phlitcol[channel].DetectedPhotons[time];
                 else
                   ++dir_phlitcol[channel].DetectedPhotons[time];
                 tmpbtr.AddScintillationPhotons(trackID, time, 1, pos, edeposit);
               }
             }
             if (Reflected)
               AddOpDetBTR(*opbtr_ref, PDChannelToSOCMapReflect, tmpbtr);
             else
               AddOpDetBTR(*opbtr, PDChannelToSOCMapDirect, tmpbtr);
           }
           // SimPhotons case
           else {
             sim::OnePhoton photon;
             photon.SetInSD = false;
             photon.InitialPosition = edepi.End();
             photon.MotherTrackID = edepi.TrackID();
             if (Reflected)
               photon.Energy = 2.9 * CLHEP::eV; // 430 nm
             else
               photon.Energy = 9.7 * CLHEP::eV; // 128 nm
             // TODO: un-hardcode and add another energy for Xe scintillation
             if (ndetected_fast > 0 && fDoFastComponent) {
               int n = ndetected_fast;
               num_fastdp += n;
               for (int i = 0; i < n; ++i) {
                 // calculates the time at which the photon was produced
                 double dtime = edepi.StartT() + fScintTime->fastScintTime();
                 if (fIncludePropTime) dtime += transport_time[i];
                 int time = static_cast<int>(std::round(dtime));
                 photon.Time = time;
                 if (Reflected)
                   ref_photcol[channel].insert(ref_photcol[channel].end(), 1, photon);
                 else
                   dir_photcol[channel].insert(dir_photcol[channel].end(), 1, photon);
               }
             }
             if (ndetected_slow > 0 && fDoSlowComponent) {
               int n = ndetected_slow;
               num_slowdp += n;
               for (int i = 0; i < n; ++i) {
                 double dtime = edepi.StartT() + fScintTime->slowScintTime();
                 if (fIncludePropTime) dtime += transport_time[ndetected_fast + i];
                 int time = static_cast<int>(std::round(dtime));
                 photon.Time = time;
                 if (Reflected)
                   ref_photcol[channel].insert(ref_photcol[channel].end(), 1, photon);
                 else
                   dir_photcol[channel].insert(dir_photcol[channel].end(), 1, photon);
               }
             }
           }
         }
       }
     }
 
     mf::LogTrace("PDFastSimPAR") << "Total points: " << num_points
                                  << ", total fast photons: " << num_fastph
                                  << ", total slow photons: " << num_slowph
                                  << "\ndetected fast photons: " << num_fastdp
                                  << ", detected slow photons: " << num_slowdp;
 
     if (fUseLitePhotons) {
       event.put(move(phlit));
       event.put(move(opbtr));
       if (fDoReflectedLight) {
         event.put(move(phlit_ref), "Reflected");
         event.put(move(opbtr_ref), "Reflected");
       }
     }
     else {
       event.put(move(phot));
       if (fDoReflectedLight) { event.put(move(phot_ref), "Reflected"); }
     }
 
     return;
   }

void art::Modifier::registerProducts ( ProductDescriptions & productsToRegister )

inherited

Definition at line 16 of file Modifier.cc.

References art::ModuleBase::moduleDescription(), and art::ProductRegistryHelper::registerProducts().

   {
     ProductRegistryHelper::registerProducts(productsToRegister,
                                             moduleDescription());
   }

void art::ModuleBase::setModuleDescription ( ModuleDescription const & md )

inherited

Definition at line 31 of file ModuleBase.cc.

References art::ModuleBase::md_.

   {
     md_ = md;
   }

void art::ModuleBase::sortConsumables ( std::string const & current_process_name )

inherited

Definition at line 49 of file ModuleBase.cc.

References art::ModuleBase::collector_, and art::ConsumesCollector::sortConsumables().

   {
     // Now that we know we have seen all the consumes declarations,
     // sort the results for fast lookup later.
     collector_.sortConsumables(current_process_name);
   }