Inheritance diagram for daq::FilterNoiseICARUS:

Classes
class	multiThreadFragmentProcessing

Public Types
using	RawDigitCollection = std::vector< raw::RawDigit >

using	RawDigitCollectionPtr = std::unique_ptr< RawDigitCollection >

using	ConcurrentRawDigitCol = tbb::concurrent_vector< raw::RawDigit >

Public Member Functions
	FilterNoiseICARUS (fhicl::ParameterSet const &pset, art::ProcessingFrame const &frame)

virtual	~FilterNoiseICARUS ()
	Destructor. More...

virtual void	configure (fhicl::ParameterSet const &pset)

virtual void	produce (art::Event &e, art::ProcessingFrame const &frame)

virtual void	beginJob (art::ProcessingFrame const &frame)
	Begin job method. More...

virtual void	endJob (art::ProcessingFrame const &frame)
	End job method. More...

void	processSingleFragment (size_t, detinfo::DetectorClocksData const &clockData, art::Handle< artdaq::Fragments >, ConcurrentRawDigitCol &, ConcurrentRawDigitCol &, ConcurrentRawDigitCol &) const

Private Member Functions
void	saveRawDigits (const icarus_signal_processing::ArrayFloat &, const icarus_signal_processing::VectorFloat &, const icarus_signal_processing::VectorFloat &, const icarus_signal_processing::VectorInt &, ConcurrentRawDigitCol &) const

Private Attributes
std::vector< std::unique_ptr < IDecoderFilter > >	fDecoderToolVec
	Decoder tools. More...

art::InputTag	fFragmentsLabel
	The input artdaq fragment label. More...

bool	fOutputPedestalCor
	Should we output pedestal corrected (not noise filtered)? More...

bool	fOutputCorrection
	Should we output the coherent noise correction vectors? More...

std::string	fOutputPedCorPath
	Path to assign to the output if asked for. More...

std::string	fOutputCoherentPath
	Path to assign to the output if asked for. More...

unsigned int	fPlaneToSimulate
	Use to get fragment offset. More...

int	fNumEvent
	Number of events seen. More...

size_t	fFragmentOffset
	The fragment offset to set channel numbering. More...

geo::GeometryCore const *	fGeometry
	pointer to Geometry service More...

Detailed Description

Definition at line 56 of file FilterNoiseICARUS_module.cc.

Member Typedef Documentation

using daq::FilterNoiseICARUS::ConcurrentRawDigitCol = tbb::concurrent_vector<raw::RawDigit>

Definition at line 73 of file FilterNoiseICARUS_module.cc.

using daq::FilterNoiseICARUS::RawDigitCollection = std::vector<raw::RawDigit>

Definition at line 71 of file FilterNoiseICARUS_module.cc.

using daq::FilterNoiseICARUS::RawDigitCollectionPtr = std::unique_ptr<RawDigitCollection>

Definition at line 72 of file FilterNoiseICARUS_module.cc.

Constructor & Destructor Documentation

daq::FilterNoiseICARUS::FilterNoiseICARUS	(	fhicl::ParameterSet const &	pset,
		art::ProcessingFrame const &	frame
	)

explicit

Constructor.

Arguments:

pset - Fcl parameters.

Definition at line 149 of file FilterNoiseICARUS_module.cc.

                                                                                                     :
                       art::ReplicatedProducer(pset, frame),
                       fNumEvent(0)
 {
     fGeometry = lar::providerFrom<geo::Geometry>();
 
     configure(pset);
 
     // Check the concurrency 
     int max_concurrency = tbb::this_task_arena::max_concurrency();
 
     mf::LogDebug("FilterNoiseICARUS") << "     ==> concurrency: " << max_concurrency << std::endl;
 
     // Recover the vector of fhicl parameters for the ROI tools
     const fhicl::ParameterSet& decoderToolParams = pset.get<fhicl::ParameterSet>("DecoderTool");
     
     fDecoderToolVec.resize(max_concurrency);
     
     for(auto& decoderTool : fDecoderToolVec)
     {
         // Get instance of tool
         decoderTool = art::make_tool<IDecoderFilter>(decoderToolParams);
     }
 
     // Compute the fragment offset from the channel number for the desired plane
     // Get a base channel number for the plane we want
     mf::LogDebug("FilterNoiseICARUS") << "ICARUS has " << fGeometry->Nchannels() << " in total with " << fGeometry->Views().size() << " views" << std::endl;
 
     geo::WireID wireID(0, 0, fPlaneToSimulate, 0);
 
     mf::LogDebug("FilterNoiseICARUS") << "WireID: " << wireID << std::endl;
 
     geo::WireID firstWireID = fGeometry->GetBeginWireID(geo::PlaneID(0,0,fPlaneToSimulate));
 
     mf::LogDebug("FilterNoiseICARUS") << "From geo, first WireID: " << firstWireID << std::endl;
 
     raw::ChannelID_t channel = fGeometry->PlaneWireToChannel(wireID);
 
     mf::LogDebug("FilterNoiseICARUS") << "Channel: " << channel << std::endl;
 
     for(size_t thePlane = 0; thePlane < 3; thePlane++)
     {
         geo::WireID  tempWireID(0, 0, thePlane, 0);
         geo::PlaneID tempPlaneID = tempWireID.planeID();
 
         mf::LogDebug("FilterNoiseICARUS") << "thePlane: " << thePlane << ", WireID: " << tempWireID << ", channel: " << 
         fGeometry->PlaneWireToChannel(tempWireID) << ", view: " << fGeometry->View(tempPlaneID) << std::endl;
     }
 
     fFragmentOffset = channel / 576;
 
     produces<std::vector<raw::RawDigit>>();
 
     if (fOutputPedestalCor)
         produces<std::vector<raw::RawDigit>>(fOutputPedCorPath);
 
     if (fOutputCorrection)
         produces<std::vector<raw::RawDigit>>(fOutputCoherentPath);
 
     // Report.
     mf::LogInfo("FilterNoiseICARUS") << "FilterNoiseICARUS configured\n";
 }

daq::FilterNoiseICARUS::~FilterNoiseICARUS ( )

virtual

Destructor.

Definition at line 214 of file FilterNoiseICARUS_module.cc.

215 {}

Member Function Documentation

void daq::FilterNoiseICARUS::beginJob ( art::ProcessingFrame const & frame )

virtual

Begin job method.

Definition at line 236 of file FilterNoiseICARUS_module.cc.

 { 
     return;
 }

void daq::FilterNoiseICARUS::configure ( fhicl::ParameterSet const & pset )

virtual

Reconfigure method.

Arguments:

pset - Fcl parameter set.

Definition at line 224 of file FilterNoiseICARUS_module.cc.

 {
     fFragmentsLabel     = pset.get<art::InputTag>("FragmentsLabel",    "daq:PHYSCRATEDATA");
     fOutputPedestalCor  = pset.get<bool         >("OutputPedestalCor",               false);
     fOutputCorrection   = pset.get<bool         >("OutputCorrection",                false);
     fOutputPedCorPath   = pset.get<std::string  >("OutputPedCorPath",                "RAW");
     fOutputCoherentPath = pset.get<std::string  >("OutputCoherentPath",              "Cor");
     fPlaneToSimulate    = pset.get<unsigned int >("PlaneToSimulate",                     2);
 }

void daq::FilterNoiseICARUS::endJob ( art::ProcessingFrame const & frame )

virtual

End job method.

Definition at line 420 of file FilterNoiseICARUS_module.cc.

 {
     mf::LogInfo("FilterNoiseICARUS") << "Looked at " << fNumEvent << " events" << std::endl;
 }

void daq::FilterNoiseICARUS::processSingleFragment	(	size_t	idx,
		detinfo::DetectorClocksData const &	clockData,
		art::Handle< artdaq::Fragments >	fragmentHandle,
		ConcurrentRawDigitCol &	rawDigitCollection,
		ConcurrentRawDigitCol &	rawRawDigitCollection,
		ConcurrentRawDigitCol &	coherentCollection
	)		const

Definition at line 326 of file FilterNoiseICARUS_module.cc.

 {
     cet::cpu_timer theClockProcess;
 
     theClockProcess.start();
 
     art::Ptr<artdaq::Fragment> fragmentPtr(fragmentHandle, idx);
 
     mf::LogDebug("FilterNoiseICARUS") << "--> Processing fragment ID: " << fragmentPtr->fragmentID() << std::endl;
     mf::LogDebug("FilterNoiseICARUS") << "    ==> Current thread index: " << tbb::this_task_arena::current_thread_index() << std::endl;
 
     // Recover pointer to the decoder needed here
     IDecoderFilter* decoderTool = fDecoderToolVec[tbb::this_task_arena::current_thread_index()].get();
 
     //process_fragment(event, rawfrag, product_collection, header_collection);
     decoderTool->process_fragment(clockData, *fragmentPtr);
 
     // Useful numerology
     // convert fragment to Nevis fragment
     icarus::PhysCrateFragment physCrateFragment(*fragmentPtr);
 
 //    size_t nBoardsPerFragment = physCrateFragment.nBoards();
 //    size_t nChannelsPerBoard  = physCrateFragment.nChannelsPerBoard();
 
     // Set base channel for both the board and the board/fragment
 //    size_t boardFragOffset    = nChannelsPerBoard * nBoardsPerFragment * (fragmentPtr->fragmentID() + fFragmentOffset);
 
     theClockProcess.stop();
 
     double totalTime = theClockProcess.accumulated_real_time();
 
     // Save the filtered RawDigitsactive but for corrected raw digits pedestal is zero
     const icarus_signal_processing::VectorFloat  locPedsVec(decoderTool->getWaveLessCoherent().size(),0.);
     const icarus_signal_processing::VectorInt&   channelVec = decoderTool->getChannelIDs();
 
     saveRawDigits(decoderTool->getWaveLessCoherent(),locPedsVec,decoderTool->getTruncRMSVals(), channelVec, rawDigitCollection);
 
     // Optionally, save the pedestal corrected RawDigits
     if (fOutputPedestalCor)
         saveRawDigits(decoderTool->getRawWaveforms(),decoderTool->getPedestalVals(),decoderTool->getFullRMSVals(),channelVec, rawRawDigitCollection);
 
     // Also optional is to output the coherent corrections (note there will be many fewer of these! )
     if (fOutputPedestalCor)
         saveRawDigits(decoderTool->getCorrectedMedians(),decoderTool->getPedestalVals(),decoderTool->getFullRMSVals(),channelVec,coherentCollection);
 
     mf::LogDebug("FilterNoiseICARUS") << "--> Exiting fragment processing for thread: " << tbb::this_task_arena::current_thread_index() << ", time: " << totalTime << std::endl;
     return;
 }

void daq::FilterNoiseICARUS::produce	(	art::Event &	event,
		art::ProcessingFrame const &	frame
	)

virtual

Produce method.

Arguments:

evt - Art event.

This is the primary method.

Definition at line 250 of file FilterNoiseICARUS_module.cc.

 {
     ++fNumEvent;
 
     art::Handle<artdaq::Fragments> daq_handle;
     event.getByLabel(fFragmentsLabel, daq_handle);
 
     mf::LogDebug("FilterNoiseICARUS") << "**** Processing raw data fragments ****" << std::endl;
 
     // Check the concurrency 
     int max_concurrency = tbb::this_task_arena::max_concurrency();
 
     mf::LogDebug("FilterNoiseICARUS") << "     ==> concurrency: " << max_concurrency << std::endl;
 
     cet::cpu_timer theClockTotal;
 
     theClockTotal.start();
 
     ConcurrentRawDigitCol concurrentRawDigits;
     ConcurrentRawDigitCol concurrentRawRawDigits;
     ConcurrentRawDigitCol coherentRawDigits;
 
     // ... Launch multiple threads with TBB to do the deconvolution and find ROIs in parallel
     auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService>()->DataFor(event);
     multiThreadFragmentProcessing fragmentProcessing(*this,
                                                      clockData,
                                                      daq_handle,
                                                      concurrentRawDigits,
                                                      concurrentRawRawDigits,
                                                      coherentRawDigits);
 
     tbb::parallel_for(tbb::blocked_range<size_t>(0, daq_handle->size()), fragmentProcessing);
 
     // Copy the raw digits from the concurrent vector to our output vector
     RawDigitCollectionPtr rawDigitCollection = std::make_unique<std::vector<raw::RawDigit>>(std::move_iterator(concurrentRawDigits.begin()), 
                                                                                             std::move_iterator(concurrentRawDigits.end()));
 
     // Want the RawDigits to be sorted in channel order... has to be done somewhere so why not now?
     std::sort(rawDigitCollection->begin(),rawDigitCollection->end(),[](const auto& left,const auto&right){return left.Channel() < right.Channel();});
 
     // Now transfer ownership to the event store
     event.put(std::move(rawDigitCollection));
 
     if (fOutputPedestalCor)
     {
         // Copy the raw digits from the concurrent vector to our output vector
         RawDigitCollectionPtr rawRawDigitCollection = std::make_unique<std::vector<raw::RawDigit>>(std::move_iterator(concurrentRawRawDigits.begin()), 
                                                                                                    std::move_iterator(concurrentRawRawDigits.end()));
         // Want the RawDigits to be sorted in channel order... has to be done somewhere so why not now?
         std::sort(rawRawDigitCollection->begin(),rawRawDigitCollection->end(),[](const auto& left,const auto&right){return left.Channel() < right.Channel();});
 
         // Now transfer ownership to the event store
         event.put(std::move(rawRawDigitCollection),fOutputPedCorPath);
     }
 
     if (fOutputCorrection)
     {
         // Copy the raw digits from the concurrent vector to our output vector
         RawDigitCollectionPtr coherentCollection = std::make_unique<std::vector<raw::RawDigit>>(std::move_iterator(coherentRawDigits.begin()), 
                                                                                                 std::move_iterator(coherentRawDigits.end()));
         // Want the RawDigits to be sorted in channel order... has to be done somewhere so why not now?
         std::sort(coherentCollection->begin(),coherentCollection->end(),[](const auto& left,const auto&right){return left.Channel() < right.Channel();});
 
         // Now transfer ownership to the event store
         event.put(std::move(coherentCollection),fOutputCoherentPath);
     }
 
     theClockTotal.stop();
 
     double totalTime = theClockTotal.accumulated_real_time();
 
     mf::LogInfo("FilterNoiseICARUS") << "==> FilterNoiseICARUS total time: " << totalTime << std::endl;
 
     return;
 }

void daq::FilterNoiseICARUS::saveRawDigits	(	const icarus_signal_processing::ArrayFloat &	dataArray,
		const icarus_signal_processing::VectorFloat &	pedestalVec,
		const icarus_signal_processing::VectorFloat &	rmsVec,
		const icarus_signal_processing::VectorInt &	channelVec,
		ConcurrentRawDigitCol &	rawDigitCol
	)		const

private

Definition at line 380 of file FilterNoiseICARUS_module.cc.

 {
     if (!dataArray.empty())
     {
         cet::cpu_timer theClockSave;
 
         theClockSave.start();
 
         raw::RawDigit::ADCvector_t wvfm(dataArray[0].size());
 
         mf::LogDebug("FilterNoiseICARUS") << "    --> saving rawdigits for " << dataArray.size() << " channels" << std::endl;
 
         // Loop over the channels to recover the RawDigits after filtering
         for(size_t chanIdx = 0; chanIdx != dataArray.size(); chanIdx++)
         {
             const icarus_signal_processing::VectorFloat& dataVec = dataArray[chanIdx];
 
             // Need to convert from float to short int
             std::transform(dataVec.begin(),dataVec.end(),wvfm.begin(),[](const auto& val){return short(std::round(val));});
 
             ConcurrentRawDigitCol::iterator newObjItr = rawDigitCol.emplace_back(channelVec[chanIdx],wvfm.size(),wvfm); 
             newObjItr->SetPedestal(pedestalVec[chanIdx],rmsVec[chanIdx]);
         }//loop over channel indices
 
         theClockSave.stop();
 
         double totalTime = theClockSave.accumulated_real_time();
 
         mf::LogDebug("FilterNoiseICARUS") << "    --> done with save, time: " << totalTime << std::endl;
     }
 
     return;
 }