#include <opDetDigitizerWorker.hh>

Classes
class	Config

class	Semaphore

Public Member Functions
	opDetDigitizerWorker (unsigned no, const Config &config, CLHEP::HepRandomEngine *Engine, const opDetSBNDTriggerAlg &trigger_alg)

	~opDetDigitizerWorker ()

void	SetPhotonLiteHandles (const std::vector< art::Handle< std::vector< sim::SimPhotonsLite >>> *PhotonLiteHandles)

void	SetPhotonHandles (const std::vector< art::Handle< std::vector< sim::SimPhotons >>> *PhotonHandles)

void	SetWaveformHandle (std::vector< raw::OpDetWaveform > *Waveforms)

void	SetTriggeredWaveformHandle (std::vector< raw::OpDetWaveform > *Waveforms)

void	Start (detinfo::DetectorClocksData const &clockData) const

void	ApplyTriggerLocations (detinfo::DetectorClocksData const &clockData) const

Private Member Functions
unsigned	NChannelsToProcess (unsigned n) const

unsigned	StartChannelToProcess (unsigned n) const

void	CreateDirectPhotonMap (std::unordered_map< int, sim::SimPhotons > &directPhotonsOnPMTS, std::vector< art::Handle< std::vector< sim::SimPhotons >>> photon_handles) const

void	CreateDirectPhotonMapLite (std::unordered_map< int, sim::SimPhotonsLite > &directPhotonsOnPMTS, std::vector< art::Handle< std::vector< sim::SimPhotonsLite >>> photon_handles) const

void	MakeWaveforms (opdet::DigiPMTSBNDAlg pmtDigitizer, opdet::DigiArapucaSBNDAlg arapucaDigitizer) const

Private Attributes
Config	fConfig

unsigned	fThreadNo

CLHEP::HepRandomEngine *	fEngine

const opDetSBNDTriggerAlg &	fTriggerAlg

const std::vector< art::Handle < std::vector < sim::SimPhotonsLite > > > *	fPhotonLiteHandles

const std::vector< art::Handle < std::vector< sim::SimPhotons > > > *	fPhotonHandles

std::vector< raw::OpDetWaveform > *	fWaveforms

std::vector< raw::OpDetWaveform > *	fTriggeredWaveforms

Detailed Description

Definition at line 27 of file opDetDigitizerWorker.hh.

Constructor & Destructor Documentation

opdet::opDetDigitizerWorker::opDetDigitizerWorker	(	unsigned	no,
		const Config &	config,
		CLHEP::HepRandomEngine *	Engine,
		const opDetSBNDTriggerAlg &	trigger_alg
	)

Definition at line 11 of file opDetDigitizerWorker.cc.

                                                                                          :
   fConfig(config),
   fThreadNo(no),
   fEngine(Engine),
   fTriggerAlg(trigger_alg)
 {}

opdet::opDetDigitizerWorker::~opDetDigitizerWorker ( )

Definition at line 107 of file opDetDigitizerWorker.cc.

 {
   delete fEngine;
 }

Member Function Documentation

void opdet::opDetDigitizerWorker::ApplyTriggerLocations ( detinfo::DetectorClocksData const & clockData ) const

Definition at line 112 of file opDetDigitizerWorker.cc.

 {
   unsigned start = StartChannelToProcess(fConfig.nChannels);
   unsigned n = NChannelsToProcess(fConfig.nChannels);
 
   fTriggeredWaveforms->clear();
 
   // apply the triggers and save the output
   for (const raw::OpDetWaveform &waveform : *fWaveforms){
     if (waveform.ChannelNumber() == std::numeric_limits<raw::Channel_t>::max() /* "NULL" value*/) {
       continue;
     }
     // only work on the prescribed channels
     if (waveform.ChannelNumber() < start || waveform.ChannelNumber() >= start + n) continue;
 
     std::vector<raw::OpDetWaveform> waveforms = fTriggerAlg.ApplyTriggerLocations(clockData, waveform);
 
     std::move(waveforms.begin(), waveforms.end(), std::back_inserter(*fTriggeredWaveforms));
   }
 }

void opdet::opDetDigitizerWorker::CreateDirectPhotonMap	(	std::unordered_map< int, sim::SimPhotons > &	directPhotonsOnPMTS,
		std::vector< art::Handle< std::vector< sim::SimPhotons >>>	photon_handles
	)		const

private

void opdet::opDetDigitizerWorker::CreateDirectPhotonMapLite	(	std::unordered_map< int, sim::SimPhotonsLite > &	directPhotonsOnPMTS,
		std::vector< art::Handle< std::vector< sim::SimPhotonsLite >>>	photon_handles
	)		const

private

void opdet::opDetDigitizerWorker::MakeWaveforms	(	opdet::DigiPMTSBNDAlg *	pmtDigitizer,
		opdet::DigiArapucaSBNDAlg *	arapucaDigitizer
	)		const

private

Definition at line 133 of file opDetDigitizerWorker.cc.

 {
   if(fConfig.UseSimPhotonsLite) {
     const std::vector<art::Handle<std::vector<sim::SimPhotonsLite>>> &photon_handles = *fPhotonLiteHandles;
 
     // TODO: Instead of looping and evaluating if/else through all the photon_handles
     // we should get smaller containers with only the relevant handles for each case
     // ~icaza
     // std::vector<art::Handle<std::vector<sim::SimPhotonsLite>> const*> ptr_photon_handles(photon_handles.size());
     // std::transform(photon_handles.begin(), photon_handles.end(), ptr_photon_handles.begin(),
     //                [](auto& p) {return std::addressof(p);});
 
     // to temporarily store channel and combine PMT (direct and converted) time profiles
 
 
     //need to combine direct and reflected photons
     std::unordered_map<std::string, std::unordered_map<int, sim::SimPhotonsLite> > AllPhotonsMap;
     AllPhotonsMap["Direct"] = std::unordered_map<int, sim::SimPhotonsLite>();
     AllPhotonsMap["Reflected"] = std::unordered_map<int, sim::SimPhotonsLite>();
     for (const art::Handle<std::vector<sim::SimPhotonsLite>> &opdetHandle : photon_handles) {
       const bool Reflected = (opdetHandle.provenance()->productInstanceName() == "Reflected");
       for (auto const& litesimphotons : (*opdetHandle)){
 
         if(Reflected){
           auto it = AllPhotonsMap["Reflected"].find(litesimphotons.OpChannel);
           if(it==AllPhotonsMap["Reflected"].end())
             AllPhotonsMap["Reflected"][litesimphotons.OpChannel] = litesimphotons;
           else
             AllPhotonsMap["Reflected"][litesimphotons.OpChannel] += litesimphotons;
         }
 
         else{ //Direct
           auto it = AllPhotonsMap["Direct"].find(litesimphotons.OpChannel);
           if(it==AllPhotonsMap["Direct"].end())
             AllPhotonsMap["Direct"][litesimphotons.OpChannel] = litesimphotons;
           else
             AllPhotonsMap["Direct"][litesimphotons.OpChannel] += litesimphotons;
         }
       }
     }
 
     const double startTime = fConfig.EnableWindow[0] * 1000. /*ns for digitizer*/;
 
     std::unordered_map<int, sim::SimPhotonsLite> DirectPhotonsMap;
     std::unordered_map<int, sim::SimPhotonsLite> ReflectedPhotonsMap;
     std::unordered_set<short unsigned int> coatedpmts_todigitize;
 
     const unsigned start = StartChannelToProcess(fConfig.nChannels);
     const unsigned n = NChannelsToProcess(fConfig.nChannels);
     for (auto const& simphotons_cols : AllPhotonsMap){
       // this now tells you if light collection is reflected
       const bool Reflected = (simphotons_cols.first=="Reflected");
       for (auto const& simphotons_map : simphotons_cols.second) {
 
         auto const& litesimphotons = simphotons_map.second;
 
         std::vector<short unsigned int> waveform;
         waveform.reserve(fConfig.Nsamples);
         const unsigned ch = litesimphotons.OpChannel;
         const std::string pdtype = fConfig.pdsMap.pdType(ch);
 
         // only work on the prescribed channels
         if (ch < start || ch >= start + n) continue;
 
 
         if( pdtype == "pmt_coated" ){
           if(Reflected)
             ReflectedPhotonsMap.insert(std::make_pair(ch, litesimphotons));
           else
             DirectPhotonsMap.insert(std::make_pair(ch, litesimphotons));
 
           coatedpmts_todigitize.insert(ch);
         }
         else if( (Reflected) && (pdtype == "pmt_uncoated") ) { //Uncoated PMT channels
           pmtDigitizer->ConstructWaveformLite(ch,
                                               litesimphotons,
                                               waveform,
                                               pdtype,
                                               startTime,
                                               fConfig.Nsamples);
           // including pre trigger window and transit time
           fWaveforms->at(ch) = raw::OpDetWaveform(fConfig.EnableWindow[0],
                                                   (unsigned int)ch,
                                                   waveform);
         }
         // getting only xarapuca channels with appropriate type of light
         else if((pdtype == "xarapuca_vuv" && !Reflected) ||
                 (pdtype == "xarapuca_vis" && Reflected) ) {
           const bool is_daphne= fConfig.pdsMap.isElectronics(ch,"daphne");
           if(is_daphne){
             arapucaDigitizer->ConstructWaveformLite(ch,
                                                   litesimphotons,
                                                   waveform,
                                                   pdtype,
                                                   is_daphne,
                                                   startTime,
                                                   fConfig.Nsamples_Daphne);
             // including pre trigger window and transit time
             fWaveforms->at(ch) = raw::OpDetWaveform(fConfig.EnableWindow[0],
                                                   (unsigned int)ch,
                                                   waveform);
             }
             else{
             arapucaDigitizer->ConstructWaveformLite(ch,
                                                   litesimphotons,
                                                   waveform,
                                                   pdtype,
                                                   is_daphne,
                                                   startTime,
                                                   fConfig.Nsamples);
             // including pre trigger window and transit time
             fWaveforms->at(ch) = raw::OpDetWaveform(fConfig.EnableWindow[0],
                                                   (unsigned int)ch,
                                                   waveform);
           }
         }
       }
     }  //end loop on simphoton lite collections
 
     //Constructing Waveforms for hybrid OpChannels (coated pmts)
     for(auto ch : coatedpmts_todigitize){
       std::vector<short unsigned int> waveform;
       waveform.reserve(fConfig.Nsamples);
       pmtDigitizer->ConstructWaveformLiteCoatedPMT(ch, waveform, DirectPhotonsMap, ReflectedPhotonsMap, startTime, fConfig.Nsamples);
       fWaveforms->at(ch) = raw::OpDetWaveform(fConfig.EnableWindow[0],
                                               (unsigned int)ch,
                                               waveform);
     }
   }
   else { // for SimPhotons
     const std::vector<art::Handle<std::vector<sim::SimPhotons>>> &photon_handles = *fPhotonHandles;
 
     //need to combine direct and reflected photons
     std::unordered_map<std::string, std::unordered_map<int, sim::SimPhotons> > AllPhotonsMap;
     AllPhotonsMap["Direct"] = std::unordered_map<int, sim::SimPhotons>();
     AllPhotonsMap["Reflected"] = std::unordered_map<int, sim::SimPhotons>();
     for (const art::Handle<std::vector<sim::SimPhotons>> &opdetHandle : photon_handles) {
       const bool Reflected = (opdetHandle.provenance()->productInstanceName() == "Reflected");
       for (auto const& simphotons : (*opdetHandle)){
 
         if(Reflected){
           auto it = AllPhotonsMap["Reflected"].find(simphotons.OpChannel());
           if(it==AllPhotonsMap["Reflected"].end())
             AllPhotonsMap["Reflected"][simphotons.OpChannel()] = simphotons;
           else
             AllPhotonsMap["Reflected"][simphotons.OpChannel()] += simphotons;
         }
 
         else{ //Direct
           auto it = AllPhotonsMap["Direct"].find(simphotons.OpChannel());
           if(it==AllPhotonsMap["Direct"].end())
             AllPhotonsMap["Direct"][simphotons.OpChannel()] = simphotons;
           else
             AllPhotonsMap["Direct"][simphotons.OpChannel()] += simphotons;
         }
       }
     }
 
 
     // to temporarily store channel and direct light distribution
     std::unordered_map<int, sim::SimPhotons> DirectPhotonsMap;
     std::unordered_map<int, sim::SimPhotons> ReflectedPhotonsMap;
     std::unordered_set<short unsigned int> coatedpmts_todigitize;
 
     const double startTime = fConfig.EnableWindow[0] * 1000. /*ns for digitizer*/;
 
     const unsigned start = StartChannelToProcess(fConfig.nChannels);
     const unsigned n = NChannelsToProcess(fConfig.nChannels);
     for (auto const& simphotons_cols : AllPhotonsMap){
       // this now tells you if light collection is reflected
       const bool Reflected = (simphotons_cols.first=="Reflected");
       for (auto const& simphotons_map : simphotons_cols.second) {
 
         auto const& simphotons = simphotons_map.second;
 
         std::vector<short unsigned int> waveform;
         const unsigned ch = simphotons.OpChannel();
         const std::string pdtype = fConfig.pdsMap.pdType(ch);
         const bool is_daphne = fConfig.pdsMap.isElectronics(ch,"daphne");
         // only work on the prescribed channels
         if (ch < start || ch >= start + n) continue;
         //coated PMTs
         if( pdtype == "pmt_coated" ){
           if(Reflected)
             ReflectedPhotonsMap.insert(std::make_pair(ch, simphotons));
           else
             DirectPhotonsMap.insert(std::make_pair(ch, simphotons));
 
           coatedpmts_todigitize.insert(ch);
         }
         // uncoated PMTs
         else if(Reflected && pdtype == "pmt_uncoated") {
           pmtDigitizer->ConstructWaveform(ch,
                                           simphotons,
                                           waveform,
                                           pdtype,
                                           startTime,
                                           fConfig.Nsamples);
           // including pre trigger window and transit time
           fWaveforms->at(ch) = raw::OpDetWaveform(fConfig.EnableWindow[0],
                                                   (unsigned int)ch,
                                                   waveform);
         }
         // getting only xarapuca channels with appropriate type of light
         if((pdtype == "xarapuca_vuv" && !Reflected) ||
            (pdtype == "xarapuca_vis" && Reflected)) {
           if(is_daphne){
           arapucaDigitizer->ConstructWaveform(ch,
                                               simphotons,
                                               waveform,
                                               pdtype,
                                               is_daphne,
                                               startTime,
                                               fConfig.Nsamples_Daphne);
           // including pre trigger window and transit time
           fWaveforms->at(ch) = raw::OpDetWaveform(fConfig.EnableWindow[0],
                                                   (unsigned int)ch,
                                                   waveform);
         }
         else{
         arapucaDigitizer->ConstructWaveform(ch,
                                               simphotons,
                                               waveform,
                                               pdtype,
                                               is_daphne,
                                               startTime,
                                               fConfig.Nsamples);
           // including pre trigger window and transit time
           fWaveforms->at(ch) = raw::OpDetWaveform(fConfig.EnableWindow[0],
                                                   (unsigned int)ch,
                                                   waveform);
         }
         }
       }//optical channel loop
     }//type of light loop
     //Constructing Waveforms for hybrid OpChannels (coated pmts)
     for(auto ch : coatedpmts_todigitize){
       std::vector<short unsigned int> waveform;
       waveform.reserve(fConfig.Nsamples);
       pmtDigitizer->ConstructWaveformCoatedPMT(ch, waveform, DirectPhotonsMap, ReflectedPhotonsMap, startTime, fConfig.Nsamples);
       fWaveforms->at(ch) = raw::OpDetWaveform(fConfig.EnableWindow[0],
                                               (unsigned int)ch,
                                               waveform);
     }
   }//simphotons end
 }

unsigned opdet::opDetDigitizerWorker::NChannelsToProcess ( unsigned n ) const

private

Definition at line 78 of file opDetDigitizerWorker.cc.

 {
   return (n + fConfig.nThreads - fThreadNo - 1) / fConfig.nThreads;
 }

void opdet::opDetDigitizerWorker::SetPhotonHandles ( const std::vector< art::Handle< std::vector< sim::SimPhotons >>> * PhotonHandles )

inline

Definition at line 71 of file opDetDigitizerWorker.hh.

     {
       fPhotonHandles = PhotonHandles;
     }

void opdet::opDetDigitizerWorker::SetPhotonLiteHandles ( const std::vector< art::Handle< std::vector< sim::SimPhotonsLite >>> * PhotonLiteHandles )

inline

Definition at line 67 of file opDetDigitizerWorker.hh.

     {
       fPhotonLiteHandles = PhotonLiteHandles;
     }

void opdet::opDetDigitizerWorker::SetTriggeredWaveformHandle ( std::vector< raw::OpDetWaveform > * Waveforms )

inline

Definition at line 79 of file opDetDigitizerWorker.hh.

     {
       fTriggeredWaveforms = Waveforms;
     }

void opdet::opDetDigitizerWorker::SetWaveformHandle ( std::vector< raw::OpDetWaveform > * Waveforms )

inline

Definition at line 75 of file opDetDigitizerWorker.hh.

     {
       fWaveforms = Waveforms;
     }

void opdet::opDetDigitizerWorker::Start ( detinfo::DetectorClocksData const & clockData ) const

Definition at line 90 of file opDetDigitizerWorker.cc.

 {
   auto arapucaDigitizer = fConfig.makeArapucaDigi(
                             *(lar::providerFrom<detinfo::LArPropertiesService>()),
                             clockData,
                             fEngine
                           );
 
   auto pmtDigitizer = fConfig.makePMTDigi(
                         *(lar::providerFrom<detinfo::LArPropertiesService>()),
                         clockData,
                         fEngine
                       );
   MakeWaveforms(pmtDigitizer.get(), arapucaDigitizer.get());
 
 }

unsigned opdet::opDetDigitizerWorker::StartChannelToProcess ( unsigned n ) const

private

Definition at line 83 of file opDetDigitizerWorker.cc.

 {
   unsigned n_per_job = n / fConfig.nThreads;
   unsigned leftover = std::min(fThreadNo, n % fConfig.nThreads);
   return n_per_job * fThreadNo + leftover;
 }

Member Data Documentation

Config opdet::opDetDigitizerWorker::fConfig

private

Definition at line 100 of file opDetDigitizerWorker.hh.

CLHEP::HepRandomEngine* opdet::opDetDigitizerWorker::fEngine

private

Definition at line 102 of file opDetDigitizerWorker.hh.

const std::vector<art::Handle<std::vector<sim::SimPhotons> > >* opdet::opDetDigitizerWorker::fPhotonHandles

private

Definition at line 106 of file opDetDigitizerWorker.hh.

const std::vector<art::Handle<std::vector<sim::SimPhotonsLite> > >* opdet::opDetDigitizerWorker::fPhotonLiteHandles

private

Definition at line 105 of file opDetDigitizerWorker.hh.

unsigned opdet::opDetDigitizerWorker::fThreadNo

private

Definition at line 101 of file opDetDigitizerWorker.hh.

const opDetSBNDTriggerAlg& opdet::opDetDigitizerWorker::fTriggerAlg

private

Definition at line 103 of file opDetDigitizerWorker.hh.

std::vector<raw::OpDetWaveform>* opdet::opDetDigitizerWorker::fTriggeredWaveforms

private

Definition at line 108 of file opDetDigitizerWorker.hh.

std::vector<raw::OpDetWaveform>* opdet::opDetDigitizerWorker::fWaveforms

private

Definition at line 107 of file opDetDigitizerWorker.hh.

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

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation