Inheritance diagram for phot::PDFastSimPAR:

Classes
struct	Config

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

Public Member Functions
	PDFastSimPAR (Parameters const &config)

void	produce (art::Event &) override

Private Member Functions
void	Initialization ()

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

Private Attributes
larg4::ISTPC	fISTPC

std::unique_ptr < SemiAnalyticalModel >	fVisibilityModel

std::unique_ptr < PropagationTimeModel >	fPropTimeModel

CLHEP::HepRandomEngine &	fPhotonEngine

std::unique_ptr < CLHEP::RandPoissonQ >	fRandPoissPhot

CLHEP::HepRandomEngine &	fScintTimeEngine

size_t	fNOpChannels

std::vector< geo::BoxBoundedGeo >	fActiveVolumes

int	fNTPC

std::vector< geo::Point_t >	fOpDetCenter

const art::InputTag	simTag

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

std::unique_ptr< ScintTime >	fScintTime

fhicl::ParameterSet	fVUVTimingParams

fhicl::ParameterSet	fVISTimingParams

fhicl::ParameterSet	fVUVHitsParams

fhicl::ParameterSet	fVISHitsParams

Detailed Description

Definition at line 77 of file PDFastSimPAR_module.cc.

Member Typedef Documentation

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

Definition at line 104 of file PDFastSimPAR_module.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 175 of file PDFastSimPAR_module.cc.

     : art::EDProducer{config}
     , fISTPC{*(lar::providerFrom<geo::Geometry>())}
     , fPhotonEngine(art::ServiceHandle<rndm::NuRandomService>()->createEngine(
                       *this, "HepJamesRandom", "photon", config.get_PSet(), "SeedPhoton"))
     , fScintTimeEngine(art::ServiceHandle<rndm::NuRandomService>()->createEngine(
                          *this, "HepJamesRandom", "scinttime", config.get_PSet(), "SeedScintTime"))
     , simTag(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())
     , fScintTime{art::make_tool<phot::ScintTime>(config().ScintTimeTool.get<fhicl::ParameterSet>())}
     , fVUVHitsParams(config().VUVHits.get<fhicl::ParameterSet>())
   {
     // Validate configuration options
     if(fIncludePropTime && !config().VUVTiming.get_if_present<fhicl::ParameterSet>(fVUVTimingParams)) {
       throw art::Exception(art::errors::Configuration)
         << "Propagation time simulation requested, but VUVTiming not specified." << "\n";
     }
 
     if(fDoReflectedLight && !config().VISHits.get_if_present<fhicl::ParameterSet>(fVISHitsParams)) {
       throw art::Exception(art::errors::Configuration)
         << "Reflected light simulation requested, but VisHits not specified." << "\n";
     }
 
     if (fDoReflectedLight && fIncludePropTime && !config().VISTiming.get_if_present<fhicl::ParameterSet>(fVISTimingParams)) {
       throw art::Exception(art::errors::Configuration)
         << "Reflected light propagation time simulation requested, but VISTiming not specified." << "\n";
     }
 
     if(fIncludeAnodeReflections && !config().VISHits.get_if_present<fhicl::ParameterSet>(fVISHitsParams)) {
       throw art::Exception(art::errors::Configuration)
         << "Anode reflections light simulation requested, but VisHits not specified." << "\n";
     }
 
     Initialization();
 
     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");
       }
     }
   }

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 465 of file PDFastSimPAR_module.cc.

   {
     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);
         }
       }
     }
   }

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

private

Definition at line 548 of file PDFastSimPAR_module.cc.

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

void phot::PDFastSimPAR::Initialization ( )

private

Definition at line 492 of file PDFastSimPAR_module.cc.

   {
     std::cout << "PDFastSimPAR Initialization" << std::endl;
     std::cout << "Initializing the geometry of the detector." << std::endl;
     std::cout << "Simulate using semi-analytic model for number of hits." << std::endl;
 
     fRandPoissPhot = std::make_unique<CLHEP::RandPoissonQ>(fPhotonEngine);
     geo::GeometryCore const& geom = *(lar::providerFrom<geo::Geometry>());
 
     // photo-detector visibility model (semi-analytical model)
     fVisibilityModel = std::make_unique<SemiAnalyticalModel>(fVUVHitsParams, fVISHitsParams, fDoReflectedLight, fIncludeAnodeReflections);
 
     // propagation time model
     if (fIncludePropTime) fPropTimeModel = std::make_unique<PropagationTimeModel>(fVUVTimingParams, fVISTimingParams, fScintTimeEngine, fDoReflectedLight, fGeoPropTimeOnly);
 
     // Store info from the Geometry service
     fNOpChannels = geom.NOpDets();
     fActiveVolumes = fISTPC.extractActiveLArVolume(geom);
     fNTPC = geom.NTPC();
 
     {
       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";
       }
     } // local scope
 
     if (geom.Ncryostats() > 1U) {
       if (fOnlyOneCryostat) {
         mf::LogWarning("PDFastSimPAR")
           << std::string(80, '=') << "\nA detector with " << geom.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.";
       }
     }
 
     for (size_t const i : util::counter(fNOpChannels)) {
       geo::OpDetGeo const& opDet = geom.OpDetGeoFromOpDet(i);
       fOpDetCenter.push_back(opDet.GetCenter());
     }
   }

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

private

Definition at line 558 of file PDFastSimPAR_module.cc.

   {
     // 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;
   }

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

override

Definition at line 241 of file PDFastSimPAR_module.cc.

   {
     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(simTag, edepHandle)) {
       mf::LogError("PDFastSimPAR") << "PDFastSimPAR Module Cannot getByLabel: " << simTag;
       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
                 fScintTime->GenScintTime(true, fScintTimeEngine);
                 int time;
                 if (fIncludePropTime) time = static_cast<int>(edepi.StartT() + fScintTime->GetScintTime() + transport_time[i]);
                 else time = static_cast<int>(edepi.StartT() + fScintTime->GetScintTime());
                 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) {
                 fScintTime->GenScintTime(false, fScintTimeEngine);
                 int time;
                 if (fIncludePropTime) time = static_cast<int>(edepi.StartT() + fScintTime->GetScintTime() + transport_time[ndetected_fast + i]);
                 else time = static_cast<int>(edepi.StartT() + fScintTime->GetScintTime());
                 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();
             if (Reflected) photon.Energy = 2.9 * CLHEP::eV; // 430 nm
             else photon.Energy = 9.7 * CLHEP::eV; // 128 nm
             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
                 fScintTime->GenScintTime(true, fScintTimeEngine);
                 int time;
                 if (fIncludePropTime) time = static_cast<int>(edepi.StartT() + fScintTime->GetScintTime() + transport_time[i]);
                 else time = static_cast<int>(edepi.StartT() + fScintTime->GetScintTime());
                 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) {
                 fScintTime->GenScintTime(false, fScintTimeEngine);
                 int time;
                 if (fIncludePropTime) time = static_cast<int>(edepi.StartT() + fScintTime->GetScintTime() + transport_time[ndetected_fast + i]);
                 else time = static_cast<int>(edepi.StartT() + fScintTime->GetScintTime());
                 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;
   }

Member Data Documentation

std::vector<geo::BoxBoundedGeo> phot::PDFastSimPAR::fActiveVolumes

private

Definition at line 142 of file PDFastSimPAR_module.cc.

const bool phot::PDFastSimPAR::fDoFastComponent

private

Definition at line 154 of file PDFastSimPAR_module.cc.

const bool phot::PDFastSimPAR::fDoReflectedLight

private

Definition at line 156 of file PDFastSimPAR_module.cc.

const bool phot::PDFastSimPAR::fDoSlowComponent

private

Definition at line 155 of file PDFastSimPAR_module.cc.

const bool phot::PDFastSimPAR::fGeoPropTimeOnly

private

Definition at line 159 of file PDFastSimPAR_module.cc.

const bool phot::PDFastSimPAR::fIncludeAnodeReflections

private

Definition at line 157 of file PDFastSimPAR_module.cc.

const bool phot::PDFastSimPAR::fIncludePropTime

private

Definition at line 158 of file PDFastSimPAR_module.cc.

larg4::ISTPC phot::PDFastSimPAR::fISTPC

private

Definition at line 126 of file PDFastSimPAR_module.cc.

size_t phot::PDFastSimPAR::fNOpChannels

private

Definition at line 139 of file PDFastSimPAR_module.cc.

int phot::PDFastSimPAR::fNTPC

private

Definition at line 143 of file PDFastSimPAR_module.cc.

const bool phot::PDFastSimPAR::fOnlyActiveVolume

private

Definition at line 162 of file PDFastSimPAR_module.cc.

const bool phot::PDFastSimPAR::fOnlyOneCryostat

private

Definition at line 163 of file PDFastSimPAR_module.cc.

const bool phot::PDFastSimPAR::fOpaqueCathode

private

Definition at line 161 of file PDFastSimPAR_module.cc.

std::vector<geo::Point_t> phot::PDFastSimPAR::fOpDetCenter

private

Definition at line 146 of file PDFastSimPAR_module.cc.

CLHEP::HepRandomEngine& phot::PDFastSimPAR::fPhotonEngine

private

Definition at line 135 of file PDFastSimPAR_module.cc.

std::unique_ptr<PropagationTimeModel> phot::PDFastSimPAR::fPropTimeModel

private

Definition at line 132 of file PDFastSimPAR_module.cc.

std::unique_ptr<CLHEP::RandPoissonQ> phot::PDFastSimPAR::fRandPoissPhot

private

Definition at line 136 of file PDFastSimPAR_module.cc.

std::unique_ptr<ScintTime> phot::PDFastSimPAR::fScintTime

private

Definition at line 164 of file PDFastSimPAR_module.cc.

CLHEP::HepRandomEngine& phot::PDFastSimPAR::fScintTimeEngine

private

Definition at line 137 of file PDFastSimPAR_module.cc.

const bool phot::PDFastSimPAR::fUseLitePhotons

private

Definition at line 160 of file PDFastSimPAR_module.cc.

fhicl::ParameterSet phot::PDFastSimPAR::fVISHitsParams

private

Definition at line 170 of file PDFastSimPAR_module.cc.

std::unique_ptr<SemiAnalyticalModel> phot::PDFastSimPAR::fVisibilityModel

private

Definition at line 129 of file PDFastSimPAR_module.cc.

fhicl::ParameterSet phot::PDFastSimPAR::fVISTimingParams

private

Definition at line 168 of file PDFastSimPAR_module.cc.

fhicl::ParameterSet phot::PDFastSimPAR::fVUVHitsParams

private

Definition at line 169 of file PDFastSimPAR_module.cc.

fhicl::ParameterSet phot::PDFastSimPAR::fVUVTimingParams

private

Definition at line 167 of file PDFastSimPAR_module.cc.

const art::InputTag phot::PDFastSimPAR::simTag

private

Definition at line 153 of file PDFastSimPAR_module.cc.

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

PDFastSimPAR_module.cc

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation