Inheritance diagram for opdet::PDSNoiseFilter:

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
	PDSNoiseFilter (Parameters const &config)

void	produce (art::Event &)

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
std::vector< float >	filter (std::vector< short unsigned int > vec, Int_t nBins)

void	TV1D_denoise (vector< float > input, vector< float > &secondFilter, const int width, const float lambda)

Private Attributes
string	fInputModule

vector< string >	fInputLabels

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 58 of file PDSNoiseFilter_module.cc.

Member Typedef Documentation

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

Definition at line 70 of file PDSNoiseFilter_module.cc.

Constructor & Destructor Documentation

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

Definition at line 95 of file PDSNoiseFilter_module.cc.

     : EDProducer{config},
       fInputModule(config().InputModule()),
       fInputLabels(config().InputLabels())
       // Additional fhicl parameters here
   {
     // Tell ART what we intend to produce
     for (auto label : fInputLabels) {
       produces< vector< raw::OpDetWaveform > >(label);
     }
   }

Member Function Documentation

std::vector< float > opdet::PDSNoiseFilter::filter	(	std::vector< short unsigned int >	vec,
		Int_t	nBins
	)

private

Definition at line 177 of file PDSNoiseFilter_module.cc.

                                                                                         {
       
       Int_t mobileAVG = 5;                    // stablish how big the mobile average will be
       Double_t avg = 0;                       // saves the average value for each bin
       vector<float> firstFilter(nBins);       // values after mobile average
       vector<float> secondFilter(nBins);      // values after mobile average
       Int_t nComp = vec.size();               // size of the vector
       Int_t  c1=0;                            // counter for n>mobileAVG and n<nComp-mobileAVG
       Int_t  c2=0;                            // counter for n<=mobileAVG
       Int_t  c0=0;                            // counter for n>=nComp-mobileAVG
       
       for(Int_t n=0; n<nComp ; n++){
           if(n>mobileAVG && n<nComp-mobileAVG){
               for(Int_t i=n-mobileAVG; i<=n+mobileAVG; i++){avg = avg + vec[i]; c0=c0+1;}
               avg = avg/c0;
               firstFilter[n] = avg;
               avg=0;
               c0=0;
           }
           else{
               if(n<=mobileAVG){
                   for(Int_t i=0; i<=n+mobileAVG; i++){ avg = avg + vec[i]; c1=c1+1;}
                   avg = avg/c1;
                   firstFilter[n] = avg;
                   avg = 0;
                   c1=0;
               }
               else if(n>=nComp-mobileAVG){
                   for(Int_t i=n-mobileAVG; i<nComp; i++) {avg = avg + vec[i]; c2=c2+1;}
                   avg = avg/c2;
                   firstFilter[n] = avg;
                   avg = 0;
                   c2=0;
               }
           }
       }
       
       TV1D_denoise(firstFilter,secondFilter,nBins,10);
       
       
       
       return secondFilter;
   }

void opdet::PDSNoiseFilter::produce ( art::Event & evt )

virtual

Implements art::EDProducer.

Definition at line 108 of file PDSNoiseFilter_module.cc.

   {
 
     // Loop over the input labels
     for (auto label : fInputLabels) {
 
       // Read the waveforms in from the event record
       art::InputTag itag1(fInputModule, label);
       auto wfHandle = evt.getHandle< vector< raw::OpDetWaveform > >(itag1);
 
       // Check that they are valid
       if (!wfHandle.isValid()) {
         mf::LogWarning("PDSNoiseFilter") << "No waveforms for label" << label;
         continue;
       }
 
       // Handle -> data
       vector< raw::OpDetWaveform > in_waveforms = *wfHandle;
 
       // Create a unique_ptr to store the output
       auto out_waveforms = std::make_unique< vector< raw::OpDetWaveform > >();
 
       // Loop through the waveforms applying filtering.
       for (auto const& in_wave : in_waveforms) {
 
         //raw::OpDetWaveform out_wave(in_wave.TimeStamp(), in_wave.ChannelNumber(), in_wave.size());
         
         Int_t nBins = in_wave.size();                     // size of the input vector
         std::vector<short unsigned int > out_wave(nBins); // vector in which the filtered waveform will be saved
         std::vector<short unsigned int > out_wave_double(nBins);
           for(Int_t i=0; i<nBins; i++) out_wave_double[i]=2*in_wave[i];
             // careful, it doesn't work for vector<short>, but it does for vector<short unsigned int>
 
         //####################################################################
         //                    Beginning of the Main Code
         //####################################################################
 
         //std:vector<short> out_wave(nBins); // don't worry about the shifted baseline due to the integer of the output
         float convert = 0;  // variable used to convert from float to short
         short convert2 = 0; // sum 0.5 to the final result to try to recover the lost information from the float-short conversion 
         std::vector<float> filtered = filter(out_wave_double,nBins); // filtered waveform
         
         // loop to convert the filtered output from float to short
         // and save it into the out_wave vector
         for(Int_t i=0; i<nBins; i++){
             convert = filtered[i];
             convert2 = (short) convert + 0.5;
             out_wave[i] = convert2;
         }
 
         //####################################################################
         //                      End of the Main Code
         //####################################################################
 
         raw::OpDetWaveform out_waveFinal(in_wave.TimeStamp(), in_wave.ChannelNumber(), out_wave);
 
         out_waveforms->emplace_back(std::move(out_waveFinal));
 
       }
 
       evt.put(std::move(out_waveforms),label);
     }
 
   }

void opdet::PDSNoiseFilter::TV1D_denoise	(	vector< float >	input,
		vector< float > &	secondFilter,
		const int	width,
		const float	lambda
	)

private

Definition at line 225 of file PDSNoiseFilter_module.cc.

                                                                                                                          {
     
     if (width>0) { /*to avoid invalid memory access to input[0]*/
         int k=0, k0=0;  /*k: current sample location, k0: beginning of current segment*/
         float umin=lambda, umax=-lambda;/*u is the dual variable*/
         float vmin=input[0]-lambda, vmax=input[0]+lambda;/*bounds for the segment's value*/
         int kplus=0, kminus=0; /*last positions where umax=-lambda, umin=lambda, respectively*/
         const float twolambda=2.0*lambda;/*auxiliary variable*/
         const float minlambda=-lambda;/*auxiliary variable*/
         for (;;) {/*simple loop, the exit test is inside*/
             while (k==width-1) {/*we use the right boundary condition*/
                 if (umin<0.0) { /*vmin is too high -> negative jump necessary*/
                     do secondFilter[k0++]=vmin; while (k0<=kminus);
                     umax=(vmin=input[kminus=k=k0])+(umin=lambda)-vmax;
                 } else if (umax>0.0) {  /*vmax is too low -> positive jump necessary*/
                     do secondFilter[k0++]=vmax; while (k0<=kplus);
                     umin=(vmax=input[kplus=k=k0])+(umax=minlambda)-vmin;
                 } else {
                     vmin+=umin/(k-k0+1); 
                     do secondFilter[k0++]=vmin; while(k0<=k);
                     return;
                 }
             }
             if ((umin+=input[k+1]-vmin)<minlambda) {/*negative jump necessary*/
                 do secondFilter[k0++]=vmin; while (k0<=kminus);
                 vmax=(vmin=input[kplus=kminus=k=k0])+twolambda;
                 umin=lambda; umax=minlambda;
             } else if ((umax+=input[k+1]-vmax)>lambda) {/*positive jump necessary*/
                 do secondFilter[k0++]=vmax; while (k0<=kplus);
                 vmin=(vmax=input[kplus=kminus=k=k0])-twolambda;
                 umin=lambda; umax=minlambda;
             } else {    /*no jump necessary, we continue*/
                 k++;
                 if (umin>=lambda) {/*update of vmin*/
                     vmin+=(umin-lambda)/((kminus=k)-k0+1);
                     umin=lambda;
                 } 
                 if (umax<=minlambda) {/*update of vmax*/
                     vmax+=(umax+lambda)/((kplus=k)-k0+1);
                     umax=minlambda;
                 }
             }
 
         }
 
     }
 
   }

Member Data Documentation

vector<string> opdet::PDSNoiseFilter::fInputLabels

private

Definition at line 81 of file PDSNoiseFilter_module.cc.

string opdet::PDSNoiseFilter::fInputModule

private

Definition at line 80 of file PDSNoiseFilter_module.cc.

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

duneopdet/duneopdet/OpticalDetector/PDSNoiseFilter_module.cc

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation