Inheritance diagram for opdet::opDetDigitizerSBND:

Classes
struct	Config

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

Public Member Functions
	opDetDigitizerSBND (Parameters const &config)

	~opDetDigitizerSBND ()

	opDetDigitizerSBND (opDetDigitizerSBND const &)=delete

	opDetDigitizerSBND (opDetDigitizerSBND &&)=delete

opDetDigitizerSBND &	operator= (opDetDigitizerSBND const &)=delete

opDetDigitizerSBND &	operator= (opDetDigitizerSBND &&)=delete

void	produce (art::Event &e) override

Public Attributes
opdet::sbndPDMapAlg	map

unsigned int	nChannels = map.size()

std::vector< raw::OpDetWaveform >	fWaveforms

Private Attributes
bool	fApplyTriggers

std::unordered_map < raw::Channel_t, std::vector < double > >	fFullWaveforms

bool	fUseSimPhotonsLite

unsigned	fPMTBaseline

unsigned	fArapucaBaseline

unsigned	fNThreads

std::vector < opdet::opDetDigitizerWorker >	fWorkers

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

std::vector< std::thread >	fWorkerThreads

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

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

opdet::opDetDigitizerWorker::Semaphore	fSemStart

opdet::opDetDigitizerWorker::Semaphore	fSemFinish

bool	fFinished

opdet::opDetSBNDTriggerAlg	fTriggerAlg

Detailed Description

Definition at line 84 of file opDetDigitizerSBND_module.cc.

Member Typedef Documentation

using opdet::opDetDigitizerSBND::Parameters = art::EDProducer::Table<Config>

Definition at line 122 of file opDetDigitizerSBND_module.cc.

Constructor & Destructor Documentation

opdet::opDetDigitizerSBND::opDetDigitizerSBND ( Parameters const & config )

explicit

Definition at line 169 of file opDetDigitizerSBND_module.cc.

     : EDProducer{config}
     , fApplyTriggers(config().ApplyTriggers())
     , fUseSimPhotonsLite(config().UseSimPhotonsLite())
     , fPMTBaseline(config().pmtAlgoConfig().pmtbaseline())
     , fArapucaBaseline(config().araAlgoConfig().baseline())
     , fTriggerAlg(config().trigAlgoConfig())
   {
     opDetDigitizerWorker::Config wConfig( config().pmtAlgoConfig(), config().araAlgoConfig());
 
     fNThreads = config().NThreads();
     if (fNThreads == 0) { // autodetect -- first check env var
       const char *env = std::getenv("SBNDCODE_OPDETSIM_NTHREADS");
       // try to parse into positive integer
       if (env != NULL) {
         try {
           int n_threads = std::stoi(env);
           if (n_threads <= 0) {
             throw std::invalid_argument("Expect positive integer");
           }
           fNThreads = n_threads;
         }
         catch (...) {
           mf::LogError("OpDetDigitizer") << "Unable to parse number of threads "
                                          << "in environment variable (SBNDCODE_OPDETSIM_NTHREADS): (" << env << ").\n"
                                          << "Setting Number opdet threads to 1." << std::endl;
           fNThreads = 1;
         }
       }
     }
 
     if (fNThreads == 0) { // autodetect -- now try to get number of cpu's
       fNThreads = std::thread::hardware_concurrency();
     }
     if (fNThreads == 0) { // autodetect failed
       fNThreads = 1;
     }
     mf::LogInfo("OpDetDigitizer") << "Digitizing on n threads: " << fNThreads << std::endl;
 
     wConfig.nThreads = fNThreads;
 
     wConfig.UseSimPhotonsLite = config().UseSimPhotonsLite();
     wConfig.InputModuleName = config().InputModuleName();
 
     auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataForJob();
     auto const detProp = art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataForJob(clockData);
     wConfig.Sampling = (clockData.OpticalClock().Frequency()) / 1000.0; //in GHz
     wConfig.Sampling_Daphne =  config().araAlgoConfig().DaphneFrequency() / 1000.0; //in GHz
     wConfig.EnableWindow = fTriggerAlg.TriggerEnableWindow(clockData, detProp); // us
     wConfig.Nsamples = (wConfig.EnableWindow[1] - wConfig.EnableWindow[0]) * 1000. /*us -> ns*/ * wConfig.Sampling /* GHz */;
     wConfig.Nsamples_Daphne = (wConfig.EnableWindow[1] - wConfig.EnableWindow[0]) * 1000. /*us -> ns*/ * wConfig.Sampling_Daphne /* GHz */;
 
     fFinished = false;
 
     fWorkers.reserve(fNThreads);
     fTriggeredWaveforms.reserve(fNThreads);
     for (unsigned i = 0; i < fNThreads; i++) {
       // Set random number gen seed from the NuRandomService
       art::ServiceHandle<rndm::NuRandomService> seedSvc;
       CLHEP::HepJamesRandom *engine = new CLHEP::HepJamesRandom;
       seedSvc->registerEngine(rndm::NuRandomService::CLHEPengineSeeder(engine), "opDetDigitizerSBND" + std::to_string(i));
 
       fTriggeredWaveforms.emplace_back();
 
       // setup worker
       fWorkers.emplace_back(i, wConfig, engine, fTriggerAlg);
       fWorkers[i].SetPhotonLiteHandles(&fPhotonLiteHandles);
       fWorkers[i].SetPhotonHandles(&fPhotonHandles);
       fWorkers[i].SetWaveformHandle(&fWaveforms);
       fWorkers[i].SetTriggeredWaveformHandle(&fTriggeredWaveforms[i]);
 
       // start worker thread
       fWorkerThreads.emplace_back(opdet::opDetDigitizerWorkerThread,
                                   std::cref(fWorkers[i]),
                                   clockData,
                                   std::ref(fSemStart),
                                   std::ref(fSemFinish),
                                   fApplyTriggers,
                                   &fFinished);
     }
 
     // Call appropriate produces<>() functions here.
     produces< std::vector< raw::OpDetWaveform > >();
   }

opdet::opDetDigitizerSBND::~opDetDigitizerSBND ( )

Definition at line 254 of file opDetDigitizerSBND_module.cc.

   {
     // cleanup all of the workers
     fFinished = true;
     opdet::StartopDetDigitizerWorkers(fNThreads, fSemStart);
 
     // join the threads
     for (std::thread &thread : fWorkerThreads) thread.join();
 
   }

opdet::opDetDigitizerSBND::opDetDigitizerSBND ( opDetDigitizerSBND const & )

delete

opdet::opDetDigitizerSBND::opDetDigitizerSBND ( opDetDigitizerSBND && )

delete

Member Function Documentation

opDetDigitizerSBND& opdet::opDetDigitizerSBND::operator= ( opDetDigitizerSBND const & )

delete

opDetDigitizerSBND& opdet::opDetDigitizerSBND::operator= ( opDetDigitizerSBND && )

delete

void opdet::opDetDigitizerSBND::produce ( art::Event & e )

override

Definition at line 265 of file opDetDigitizerSBND_module.cc.

   {
     std::unique_ptr< std::vector< raw::OpDetWaveform > > pulseVecPtr(std::make_unique< std::vector< raw::OpDetWaveform > > ());
     // Implementation of required member function here.
     mf::LogInfo("opDetDigitizer") << "Event: " << e.id().event() << std::endl;
 
     // setup the waveforms
     fWaveforms = std::vector<raw::OpDetWaveform> (nChannels);
 
     auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(e);
     auto const detProp = art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(e, clockData);
 
     if (fUseSimPhotonsLite) {
       fPhotonLiteHandles.clear();
       //Get *ALL* SimPhotonsCollectionLite from Event
       fPhotonLiteHandles = e.getMany<std::vector<sim::SimPhotonsLite>>();
       if (fPhotonLiteHandles.size() == 0)
         mf::LogError("OpDetDigitizer") << "sim::SimPhotonsLite not found -> No Optical Detector Simulation!\n";
     }
     else {
       fPhotonHandles.clear();
       //Get *ALL* SimPhotonsCollection from Event
       fPhotonLiteHandles = e.getMany<std::vector<sim::SimPhotonsLite>>();
       if (fPhotonHandles.size() == 0)
         mf::LogError("OpDetDigitizer") << "sim::SimPhotons not found -> No Optical Detector Simulation!\n";
     }
     // Start the workers!
     // Run the digitizer over the full readout window
     opdet::StartopDetDigitizerWorkers(fNThreads, fSemStart);
     opdet::WaitopDetDigitizerWorkers(fNThreads, fSemFinish);
 
     if (fApplyTriggers) {
       // find the trigger locations for the waveforms
       for (const raw::OpDetWaveform &waveform : fWaveforms) {
         raw::Channel_t ch = waveform.ChannelNumber();
         // skip light channels which don't correspond to readout channels
         if (ch == std::numeric_limits<raw::Channel_t>::max() /* "NULL" value*/) {
           continue;
         }
         raw::ADC_Count_t baseline = (map.isPDType(ch, "pmt_uncoated") || map.isPDType(ch, "pmt_coated")) ?
                                     fPMTBaseline : fArapucaBaseline;
         fTriggerAlg.FindTriggerLocations(clockData, detProp, waveform, baseline);
       }
 
       // combine the triggers
       fTriggerAlg.MergeTriggerLocations();
       // Start the workers!
       // Apply the trigger locations
       opdet::StartopDetDigitizerWorkers(fNThreads, fSemStart);
       opdet::WaitopDetDigitizerWorkers(fNThreads, fSemFinish);
 
       for (std::vector<raw::OpDetWaveform> &waveforms : fTriggeredWaveforms) {
         // move these waveforms into the pulseVecPtr
         pulseVecPtr->reserve(pulseVecPtr->size() + waveforms.size());
         std::move(waveforms.begin(), waveforms.end(), std::back_inserter(*pulseVecPtr));
       }
       // clean up the vector
       for (unsigned i = 0; i < fTriggeredWaveforms.size(); i++) {
         fTriggeredWaveforms[i] = std::vector<raw::OpDetWaveform>();
       }
 
       // put the waveforms in the event
       e.put(std::move(pulseVecPtr));
       // clear out the triggers
       fTriggerAlg.ClearTriggerLocations();
 
     }
     else {
       // put the full waveforms in the event
       for (const raw::OpDetWaveform &waveform : fWaveforms) {
         if (waveform.ChannelNumber() == std::numeric_limits<raw::Channel_t>::max() /* "NULL" value*/) {
           continue;
         }
         pulseVecPtr->push_back(waveform);
       }
       e.put(std::move(pulseVecPtr));
     }
 
     // clear out the full waveforms
     fWaveforms.clear();
 
   }//produce end