phot::PDFastSimPAR Class Reference

Inheritance diagram for phot::PDFastSimPAR:

Classes
struct	Config

Public Types
using	Parameters = art::EDProducer::Table< Config >
Public Types inherited from art::EDProducer
using	ModuleType = EDProducer
using	WorkerType = WorkerT< EDProducer >
Public Types inherited from art::detail::Producer
template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >
Public Types inherited from art::Modifier
template<typename UserConfig , typename UserKeysToIgnore = void>
using	Table = ProducerTable< UserConfig, detail::ModuleConfig, UserKeysToIgnore >

Public Member Functions
	PDFastSimPAR (Parameters const &config)
void	produce (art::Event &) override
Public Member Functions inherited from art::EDProducer
	EDProducer (fhicl::ParameterSet const &pset)
template<typename Config >
	EDProducer (Table< Config > const &config)
std::string	workerType () const
Public Member Functions inherited from art::detail::Producer
virtual	~Producer () noexcept
	Producer (fhicl::ParameterSet const &)
	Producer (Producer const &)=delete
	Producer (Producer &&)=delete
Producer &	operator= (Producer const &)=delete
Producer &	operator= (Producer &&)=delete
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)
Public Member Functions inherited from art::Modifier
	~Modifier () noexcept
	Modifier ()
	Modifier (Modifier const &)=delete
	Modifier (Modifier &&)=delete
Modifier &	operator= (Modifier const &)=delete
Modifier &	operator= (Modifier &&)=delete
Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept
	ModuleBase ()
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)
template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)
template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Private Member Functions
void	Initialization ()
void	detectedNumPhotons (std::map< size_t, int > &DetectedNumPhotons, const std::map< size_t, double > &OpDetVisibilities, const double NumPhotons)
void	AddOpDetBTR (std::vector< sim::OpDetBacktrackerRecord > &opbtr, std::map< size_t, int > &ChannelMap, sim::OpDetBacktrackerRecord btr)
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	nOpDets
std::map< size_t, int >	PDChannelToSOCMapDirect
std::map< size_t, int >	PDChannelToSOCMapReflect
std::vector< geo::BoxBoundedGeo >	fActiveVolumes
int	fNTPC
std::vector< geo::Point_t >	fOpDetCenter
art::InputTag	simTag
bool	fDoFastComponent
bool	fDoSlowComponent
bool	fDoReflectedLight
bool	fIncludeAnodeReflections
bool	fIncludePropTime
bool	fGeoPropTimeOnly
bool	fUseLitePhotons
bool	fOpaqueCathode
bool	fOnlyActiveVolume
bool	fOnlyOneCryostat
std::unique_ptr< ScintTime >	fScintTime
fhicl::ParameterSet	fVUVTimingParams
fhicl::ParameterSet	fVISTimingParams
fhicl::ParameterSet	fVUVHitsParams
fhicl::ParameterSet	fVISHitsParams

Additional Inherited Members
Static Public Member Functions inherited from art::EDProducer
static void	commitEvent (EventPrincipal &ep, Event &e)
Protected Member Functions inherited from art::ModuleBase
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 ()

Detailed Description

Definition at line 91 of file PDFastSimPAR_module.cc.

Member Typedef Documentation

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

Definition at line 118 of file PDFastSimPAR_module.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 191 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<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::map< size_t, int > &  ChannelMap, sim::OpDetBacktrackerRecord  btr  )

private

Definition at line 500 of file PDFastSimPAR_module.cc.

  {
    size_t iChan = btr.OpDetNum();
    auto channelPosition = ChannelMap.find(iChan);

    if (channelPosition == ChannelMap.end()) {
      ChannelMap[iChan] = opbtr.size();
      opbtr.emplace_back(std::move(btr));
    }
    else {
      unsigned int idtest = channelPosition->second;
      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::map< size_t, int > &  DetectedNumPhotons, const std::map< size_t, double > &  OpDetVisibilities, const double  NumPhotons  )

private

Definition at line 584 of file PDFastSimPAR_module.cc.

  {
      for (auto const& x : OpDetVisibilities)
      {
        DetectedNumPhotons[x.first] = fRandPoissPhot->fire(x.second * NumPhotons);
      }
  }

void phot::PDFastSimPAR::Initialization ( )

private

Definition at line 528 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
    nOpDets = 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(nOpDets)) {
      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 595 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 )

overridevirtual

Implements art::EDProducer.

Definition at line 269 of file PDFastSimPAR_module.cc.

  {
    mf::LogTrace("PDFastSimPAR") << "PDFastSimPAR Module Producer"
                                 << "EventID: " << event.event();

    auto phot = std::make_unique<std::vector<sim::SimPhotons>>();
    auto phlit = std::make_unique<std::vector<sim::SimPhotonsLite>>();
    auto opbtr = std::make_unique<std::vector<sim::OpDetBacktrackerRecord>>();

    auto phot_ref = std::make_unique<std::vector<sim::SimPhotons>>();
    auto phlit_ref = std::make_unique<std::vector<sim::SimPhotonsLite>>();
    auto opbtr_ref = std::make_unique<std::vector<sim::OpDetBacktrackerRecord>>();

    auto& dir_photcol(*phot);
    auto& ref_photcol(*phot_ref);
    auto& dir_phlitcol(*phlit);
    auto& ref_phlitcol(*phlit_ref);
    dir_photcol.resize(nOpDets);
    ref_photcol.resize(nOpDets);
    dir_phlitcol.resize(nOpDets);
    ref_phlitcol.resize(nOpDets);
    for (unsigned int i = 0; i < nOpDets; i ++)
    {
        dir_photcol[i].fOpChannel  = i;
        ref_photcol[i].fOpChannel  = i;
        dir_phlitcol[i].OpChannel  = i;
        ref_phlitcol[i].OpChannel  = 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 trackID = edepi.TrackID();
      double 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;

      double nphot_fast = edepi.NumFPhotons();
      double nphot_slow = edepi.NumSPhotons();

      num_fastph += nphot_fast;
      num_slowph += nphot_slow;

      // direct light
      std::map<size_t, int> DetectedNumFast;
      std::map<size_t, int> DetectedNumSlow;

      bool needHits = (nphot_fast > 0 && fDoFastComponent) || (nphot_slow > 0 && fDoSlowComponent);
      if ( needHits ) {
        std::map<size_t, double> OpDetVisibilities;
        fVisibilityModel->detectedDirectVisibilities(OpDetVisibilities, ScintPoint);
        detectedNumPhotons(DetectedNumFast, OpDetVisibilities, nphot_fast);
        detectedNumPhotons(DetectedNumSlow, OpDetVisibilities, nphot_slow);
        
        if ( fIncludeAnodeReflections ) {
          std::map<size_t, int> AnodeDetectedNumFast;
          std::map<size_t, int> AnodeDetectedNumSlow;
          
          std::map<size_t, double> OpDetVisibilitiesAnode;
          fVisibilityModel->detectedReflectedVisibilities(OpDetVisibilitiesAnode, ScintPoint, true);
          detectedNumPhotons(AnodeDetectedNumFast, OpDetVisibilitiesAnode, nphot_fast);
          detectedNumPhotons(AnodeDetectedNumSlow, OpDetVisibilitiesAnode, nphot_slow);

          // add to existing count
          for (auto const& x : AnodeDetectedNumFast) DetectedNumFast[x.first] += x.second;
          for (auto const& x : AnodeDetectedNumSlow) DetectedNumSlow[x.first] += x.second;
        }
      }

      // reflected light, if enabled
      std::map<size_t, int> ReflDetectedNumFast;
      std::map<size_t, int> ReflDetectedNumSlow;
      
      if (fDoReflectedLight && needHits) {
        std::map<size_t, double> OpDetVisibilitiesRefl;
        fVisibilityModel->detectedReflectedVisibilities(OpDetVisibilitiesRefl, ScintPoint, false);
        detectedNumPhotons(ReflDetectedNumFast, OpDetVisibilitiesRefl, nphot_fast);
        detectedNumPhotons(ReflDetectedNumSlow, OpDetVisibilitiesRefl, nphot_slow);
      }

      // propagation time
      std::vector<double> transport_time;

      // loop through direct photons then reflected photons cases
      for (size_t Reflected = 0; Reflected <= 1; ++Reflected) {

        // only do the reflected loop if including reflected light
        if (Reflected && !fDoReflectedLight) continue;

        for (size_t channel = 0; channel < nOpDets; 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];
          }

          // calculate propagation time, does not matter whether fast or slow photon          
          if (fIncludePropTime && needHits) {
            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 (long 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 (long 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 (long 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 (long 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;

    PDChannelToSOCMapDirect.clear();
    PDChannelToSOCMapReflect.clear();

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

bool phot::PDFastSimPAR::fDoFastComponent

private

Definition at line 170 of file PDFastSimPAR_module.cc.

bool phot::PDFastSimPAR::fDoReflectedLight

private

Definition at line 172 of file PDFastSimPAR_module.cc.

bool phot::PDFastSimPAR::fDoSlowComponent

private

Definition at line 171 of file PDFastSimPAR_module.cc.

bool phot::PDFastSimPAR::fGeoPropTimeOnly

private

Definition at line 175 of file PDFastSimPAR_module.cc.

bool phot::PDFastSimPAR::fIncludeAnodeReflections

private

Definition at line 173 of file PDFastSimPAR_module.cc.

bool phot::PDFastSimPAR::fIncludePropTime

private

Definition at line 174 of file PDFastSimPAR_module.cc.

larg4::ISTPC phot::PDFastSimPAR::fISTPC

private

Definition at line 139 of file PDFastSimPAR_module.cc.

int phot::PDFastSimPAR::fNTPC

private

Definition at line 159 of file PDFastSimPAR_module.cc.

bool phot::PDFastSimPAR::fOnlyActiveVolume

private

Definition at line 178 of file PDFastSimPAR_module.cc.

bool phot::PDFastSimPAR::fOnlyOneCryostat

private

Definition at line 179 of file PDFastSimPAR_module.cc.

bool phot::PDFastSimPAR::fOpaqueCathode

private

Definition at line 177 of file PDFastSimPAR_module.cc.

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

private

Definition at line 162 of file PDFastSimPAR_module.cc.

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

private

Definition at line 148 of file PDFastSimPAR_module.cc.

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

private

Definition at line 145 of file PDFastSimPAR_module.cc.

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

private

Definition at line 149 of file PDFastSimPAR_module.cc.

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

private

Definition at line 180 of file PDFastSimPAR_module.cc.

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

private

Definition at line 150 of file PDFastSimPAR_module.cc.

bool phot::PDFastSimPAR::fUseLitePhotons

private

Definition at line 176 of file PDFastSimPAR_module.cc.

fhicl::ParameterSet phot::PDFastSimPAR::fVISHitsParams

private

Definition at line 186 of file PDFastSimPAR_module.cc.

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

private

Definition at line 142 of file PDFastSimPAR_module.cc.

fhicl::ParameterSet phot::PDFastSimPAR::fVISTimingParams

private

Definition at line 184 of file PDFastSimPAR_module.cc.

fhicl::ParameterSet phot::PDFastSimPAR::fVUVHitsParams

private

Definition at line 185 of file PDFastSimPAR_module.cc.

fhicl::ParameterSet phot::PDFastSimPAR::fVUVTimingParams

private

Definition at line 183 of file PDFastSimPAR_module.cc.

size_t phot::PDFastSimPAR::nOpDets

private

Definition at line 152 of file PDFastSimPAR_module.cc.

std::map<size_t, int> phot::PDFastSimPAR::PDChannelToSOCMapDirect

private

Definition at line 154 of file PDFastSimPAR_module.cc.

std::map<size_t, int> phot::PDFastSimPAR::PDChannelToSOCMapReflect

private

Definition at line 155 of file PDFastSimPAR_module.cc.

art::InputTag phot::PDFastSimPAR::simTag

private

Definition at line 169 of file PDFastSimPAR_module.cc.

---

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

• larsim/larsim/PhotonPropagation/PDFastSimPAR_module.cc