phot::PDFastSimPVS Class Reference

Inheritance diagram for phot::PDFastSimPVS:

Public Member Functions
	PDFastSimPVS (fhicl::ParameterSet const &)
void	produce (art::Event &) override
void	AddOpDetBTR (std::vector< sim::OpDetBacktrackerRecord > &opbtr, std::map< int, int > &ChannelMap, sim::OpDetBacktrackerRecord btr)
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 Attributes
bool	fDoFastComponent
bool	fDoSlowComponent
art::InputTag	simTag
std::unique_ptr< ScintTime >	fScintTime
CLHEP::HepRandomEngine &	fPhotonEngine
CLHEP::HepRandomEngine &	fScintTimeEngine
std::map< int, int >	PDChannelToSOCMapDirect
std::map< int, int >	PDChannelToSOCMapReflect
std::unique_ptr< PropagationTimeModel >	fPropTimeModel
fhicl::ParameterSet	fVUVTimingParams
fhicl::ParameterSet	fVISTimingParams
bool	fIncludePropTime

Additional Inherited Members
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 >
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 61 of file PDFastSimPVS_module.cc.

Constructor & Destructor Documentation

phot::PDFastSimPVS::PDFastSimPVS ( fhicl::ParameterSet const &  pset )

explicit

Definition at line 90 of file PDFastSimPVS_module.cc.

    : art::EDProducer{pset}
    , fDoFastComponent(pset.get<bool>("DoFastComponent", true))
    , fDoSlowComponent(pset.get<bool>("DoSlowComponent", true))
    , simTag{pset.get<art::InputTag>("SimulationLabel")}
    , fScintTime{art::make_tool<ScintTime>(pset.get<fhicl::ParameterSet>("ScintTimeTool"))}
    , fPhotonEngine(art::ServiceHandle<rndm::NuRandomService>{}->createEngine(*this, "HepJamesRandom", "photon", pset, "SeedPhoton"))
    , fScintTimeEngine(art::ServiceHandle<rndm::NuRandomService>()->createEngine(*this, "HepJamesRandom", "scinttime", pset, "SeedScintTime"))
    , fIncludePropTime(pset.get<bool>("IncludePropTime", false))
  {
    std::cout << "PDFastSimPVS Module Construct" << std::endl;
      
    art::ServiceHandle<PhotonVisibilityService const> pvs;
    art::ServiceHandle<sim::LArG4Parameters const> lgp;        
    if (lgp->UseLitePhotons())
    {
      std::cout << "Use Lite Photon." << std::endl;
      produces< std::vector<sim::SimPhotonsLite> >();
      produces< std::vector<sim::OpDetBacktrackerRecord> >();
          
      if(pvs->StoreReflected())
      {
        std::cout << "Store Reflected Photons" << std::endl;
        produces< std::vector<sim::SimPhotonsLite> >("Reflected");
        produces< std::vector<sim::OpDetBacktrackerRecord> >("Reflected");     
      }            
    }
    else
    {
      std::cout << "Use Sim Photon." << std::endl;
      produces< std::vector<sim::SimPhotons> >();
      if(pvs->StoreReflected())
      {
        std::cout << "Store Reflected Photons" << std::endl;            
        produces< std::vector<sim::SimPhotons> >("Reflected");     
      }            
    }        
  
    // Propagation times
    // validate configuration    
    if(fIncludePropTime && !pset.get_if_present<fhicl::ParameterSet>("VUVTiming", fVUVTimingParams)) 
    {
    throw art::Exception(art::errors::Configuration)
      << "Propagation time simulation requested, but VUVTiming not specified." << "\n";
    }

    if (pvs->StoreReflected() && fIncludePropTime && !pset.get_if_present<fhicl::ParameterSet>("VISTiming", fVISTimingParams)) 
    {
      throw art::Exception(art::errors::Configuration)
        << "Reflected light propagation time simulation requested, but VISTiming not specified." << "\n";
    }

    // construct propagation time class
    if (fIncludePropTime) fPropTimeModel = std::make_unique<PropagationTimeModel>(fVUVTimingParams, fVISTimingParams, fScintTimeEngine, pvs->StoreReflected());
  }

Member Function Documentation

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

Definition at line 356 of file PDFastSimPVS_module.cc.

  {
    int iChan = btr.OpDetNum();
    std::map<int, int>::iterator 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::PDFastSimPVS::produce ( art::Event &  event )

overridevirtual

Implements art::EDProducer.

Definition at line 147 of file PDFastSimPVS_module.cc.

  {
    std::cout << "PDFastSimPVS Module Producer" << std::endl;
        
    art::ServiceHandle<PhotonVisibilityService const> pvs;
    art::ServiceHandle<sim::LArG4Parameters const> lgp;
    auto const nOpChannels = pvs->NOpChannels();
        
    CLHEP::RandPoissonQ randpoisphot{fPhotonEngine};
        
    std::unique_ptr< std::vector< sim::SimPhotons > >             phot   (new std::vector<sim::SimPhotons>);
    std::unique_ptr< std::vector< sim::SimPhotonsLite > >         phlit  (new std::vector<sim::SimPhotonsLite>);
    std::unique_ptr< std::vector< sim::OpDetBacktrackerRecord > > opbtr  (new std::vector<sim::OpDetBacktrackerRecord>);
        
    std::unique_ptr< std::vector< sim::SimPhotons > >             phot_ref   (new std::vector<sim::SimPhotons>);
    std::unique_ptr< std::vector< sim::SimPhotonsLite > >         phlit_ref  (new std::vector<sim::SimPhotonsLite>);
    std::unique_ptr< std::vector< sim::OpDetBacktrackerRecord > > opbtr_ref  (new 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(nOpChannels);
    ref_photcol.resize(nOpChannels);
    dir_phlitcol.resize(nOpChannels);
    ref_phlitcol.resize(nOpChannels);
    for (unsigned int i = 0; i < nOpChannels; 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)) 
    {
      std::cout << "PDFastSimPVS Module Cannot getByLabel: " << simTag << std::endl;
      return;
    }
    else 
    {
      std::cout << "PDFastSimPVS Module getByLabel: " << simTag << std::endl;
    }
        
    auto const& edeps = edepHandle;
        
    int num_points    = 0;
        
    for (auto const& edepi: *edeps) {
      num_points ++;
            
      MappedCounts_t Visibilities;
      MappedCounts_t Visibilities_Ref;
            
      auto const& prt  = edepi.MidPoint();
      Visibilities     = pvs->GetAllVisibilities(prt);
      if(pvs->StoreReflected()) {
        Visibilities_Ref = pvs->GetAllVisibilities(prt, true);
        if(!Visibilities_Ref)  std::cout << "Fail to get visibilities for reflected photons." << std::endl;
      }
            
      if(!Visibilities)
      {
        //throw cet::exception("PDFastSimPVS")
        std::cout << "There is no entry in the PhotonLibrary for this position in space. Position: " << edepi.MidPoint();
        std::cout << "\n Move to next point" << std::endl;
        continue;
      }
      
      int trackID       = edepi.TrackID();
      int nphot         = edepi.NumPhotons();
      double edeposit   = edepi.Energy()/nphot;
      double pos[3]     = {edepi.MidPointX(), edepi.MidPointY(), edepi.MidPointZ()};
      int nphot_fast    = edepi.NumFPhotons();
      int nphot_slow    = edepi.NumSPhotons();

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

      geo::Point_t const ScintPoint = {pos[0], pos[1], pos[2]};

      // 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 && !pvs->StoreReflected()) continue;

        // loop over each photo-detector
        for (unsigned int channel = 0; channel < nOpChannels; ++ channel) {
          
          // visibility
          double visibleFraction;
          if (Reflected) visibleFraction = Visibilities_Ref[channel];   
          else visibleFraction = Visibilities[channel];

          if (visibleFraction == 0.0) continue; // voxel is not visible at this optical channel               

          // number of detected photons
          int ndetected_fast = 0;
          int ndetected_slow = 0;

          if (nphot_fast > 0) ndetected_fast = static_cast<int>(randpoisphot.fire(nphot_fast * visibleFraction));
          if (nphot_slow > 0) ndetected_slow = static_cast<int>(randpoisphot.fire(nphot_slow * visibleFraction));

          // calculate propagation times if included, does not matter whether fast or slow photon
          if (fIncludePropTime) {
            transport_time.resize(ndetected_fast + ndetected_slow);
            fPropTimeModel->propagationTime(transport_time, ScintPoint, channel, Reflected);
          }

          // SimPhotonsLite case
          if (lgp->UseLitePhotons()) {

            sim::OpDetBacktrackerRecord tmpbtr(channel);

            if (ndetected_fast > 0 && fDoFastComponent) {
              for (long i = 0; i < ndetected_fast; ++i) {
                // calculate the time at which each photon is seen
                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) {
              for (long i = 0; i < ndetected_slow; ++i) { 
                // calculate the time at which each photon is seen
                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) {
              for (long i = 0; i < ndetected_fast; ++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) {
              for (long i = 0; i < ndetected_slow; ++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);
              }
            }
          }
        }
      }
    }  

    PDChannelToSOCMapDirect.clear();
    PDChannelToSOCMapReflect.clear();
          
    if (lgp->UseLitePhotons())
    {
      event.put(move(phlit));
      event.put(move(opbtr));
      if (pvs->StoreReflected())
      {
        event.put(move(phlit_ref), "Reflected");
        event.put(move(opbtr_ref), "Reflected");
      }
    }
    else
    {
      event.put(move(phot));
      if (pvs->StoreReflected())
      {
        event.put(move(phot_ref), "Reflected");
      }
    }
          
    return;
  }

Member Data Documentation

bool phot::PDFastSimPVS::fDoFastComponent

private

Definition at line 71 of file PDFastSimPVS_module.cc.

bool phot::PDFastSimPVS::fDoSlowComponent

private

Definition at line 72 of file PDFastSimPVS_module.cc.

bool phot::PDFastSimPVS::fIncludePropTime

private

Definition at line 86 of file PDFastSimPVS_module.cc.

CLHEP::HepRandomEngine& phot::PDFastSimPVS::fPhotonEngine

private

Definition at line 75 of file PDFastSimPVS_module.cc.

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

private

Definition at line 81 of file PDFastSimPVS_module.cc.

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

private

Definition at line 74 of file PDFastSimPVS_module.cc.

CLHEP::HepRandomEngine& phot::PDFastSimPVS::fScintTimeEngine

private

Definition at line 76 of file PDFastSimPVS_module.cc.

fhicl::ParameterSet phot::PDFastSimPVS::fVISTimingParams

private

Definition at line 84 of file PDFastSimPVS_module.cc.

fhicl::ParameterSet phot::PDFastSimPVS::fVUVTimingParams

private

Definition at line 83 of file PDFastSimPVS_module.cc.

std::map<int, int> phot::PDFastSimPVS::PDChannelToSOCMapDirect

private

Definition at line 77 of file PDFastSimPVS_module.cc.

std::map<int, int> phot::PDFastSimPVS::PDChannelToSOCMapReflect

private

Definition at line 78 of file PDFastSimPVS_module.cc.

art::InputTag phot::PDFastSimPVS::simTag

private

Definition at line 73 of file PDFastSimPVS_module.cc.

---

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

• larsim/larsim/PhotonPropagation/PDFastSimPVS_module.cc