#include <PdspNoiseRemoval.h>

Inheritance diagram for PdspNoiseRemoval:

Public Member Functions
	PdspNoiseRemoval (fhicl::ParameterSet const &ps)

	~PdspNoiseRemoval () override=default

DataMap	updateMap (AdcChannelDataMap &acds) const override

Private Member Functions
std::vector< float >	getMeanCorrection (const std::vector< unsigned int > &channels, const AdcChannelDataMap &datamap) const

std::vector< float >	getMedianCorrection (const std::vector< unsigned int > &channels, const AdcChannelDataMap &datamap) const

void	removeCoherent (const GroupChannelMap &ch_groups, AdcChannelDataMap &datamap) const

void	removeHighFreq (AdcChannelDataMap &datamap) const

void	fftFltInPlace (std::vector< float > &adc, const std::vector< float > &coeffs) const

std::vector< float >	fftFlt (const std::vector< float > &adc, const std::vector< float > &coeffs) const

std::vector< bool >	roiMask (const AdcChannelData &adc) const

GroupChannelMap	makeGroupsByOfflineChannels (size_t gsize, const std::vector< size_t > &gidx) const

GroupChannelMap	makeGroupsByDAQChannels (size_t gsize, const std::vector< size_t > &gidx) const

GroupChannelMap	makeGroupsByFEMBPlaneType (size_t gsize, const std::vector< size_t > &gidx) const

bool	has (const std::vector< size_t > &v, size_t idx) const

Private Member Functions inherited from TpcDataTool
virtual DataMap	updateTpcData (TpcData &) const

virtual DataMap	viewTpcData (const TpcData &) const

virtual int	forwardTpcData () const

Private Member Functions inherited from AdcChannelTool
virtual	~AdcChannelTool ()=default

virtual DataMap	update (AdcChannelData &) const

virtual DataMap	view (const AdcChannelData &acd) const

virtual DataMap	viewMap (const AdcChannelDataMap &acds) const

virtual bool	updateWithView () const

virtual bool	viewWithUpdate () const

virtual DataMap	beginEvent (const DuneEventInfo &) const

virtual DataMap	endEvent (const DuneEventInfo &) const

virtual DataMap	close (const DataMap *dmin=nullptr)

Static Private Member Functions
static size_t	getDAQChan (size_t LAr_chan)

Static Private Member Functions inherited from AdcChannelTool
static int	interfaceNotImplemented ()

Private Attributes
int	m_LogLevel

bool	fRemoveHighFrequency

bool	fRemoveCoherent

bool	fCoherentOffline16

bool	fCoherentDaq8

bool	fCoherentDaq16

bool	fCoherentFEMB128

std::vector< size_t >	fCoherentOffline16Groups

std::vector< size_t >	fCoherentDaq8Groups

std::vector< size_t >	fCoherentDaq16Groups

std::vector< size_t >	fCoherentFEMB128Groups

std::vector< float >	fLowPassCoeffs

int	fMode

bool	fUseBasicROIForCNR

float	fRoiStartThreshold

float	fRoiEndThreshold

int	fRoiPadLow

int	fRoiPadHigh

float	fCutoffFrequency

const geo::Geometry *	fGeometry

util::LArFFT *	fFFT

Additional Inherited Members
Private Types inherited from AdcChannelTool
using	Index = unsigned int

Detailed Description

Definition at line 53 of file PdspNoiseRemoval.h.

Constructor & Destructor Documentation

PdspNoiseRemoval::PdspNoiseRemoval ( fhicl::ParameterSet const & ps )

Definition at line 56 of file PdspNoiseRemoval_tool.cc.

 : m_LogLevel(ps.get<int>("LogLevel")) {
   const string myname = "PdspNoiseRemoval::ctor: ";
   
   fRemoveHighFrequency     = ps.get<bool>("RemoveHighFrequency");
   fRemoveCoherent          = ps.get<bool>("RemoveCoherent");
   fCutoffFrequency         = ps.get<float>("CutoffFrequency");
   fCoherentOffline16       = ps.get<bool>("CoherentOffline16");
   fCoherentDaq8            = ps.get<bool>("CoherentDaq8");
   fCoherentDaq16           = ps.get<bool>("CoherentDaq16");
   fCoherentFEMB128         = ps.get<bool>("CoherentFEMB128");
   fCoherentOffline16Groups = ps.get<std::vector<size_t>>("CoherentOffline16Groups");
   fCoherentDaq8Groups      = ps.get<std::vector<size_t>>("CoherentDaq8Groups");
   fCoherentDaq16Groups     = ps.get<std::vector<size_t>>("CoherentDaq16Groups");
   fCoherentFEMB128Groups   = ps.get<std::vector<size_t>>("CoherentFEMB128Groups");
   fUseBasicROIForCNR       = ps.get<bool>("UseBasicROIForCNR");
   fRoiStartThreshold       = ps.get<float>("RoiStartThreshold");
   fRoiEndThreshold         = ps.get<float>("RoiEndThreshold");
   fRoiPadLow               = ps.get<int>("RoiPadLow");
   fRoiPadHigh              = ps.get<int>("RoiPadHigh");
   
   fGeometry = &*art::ServiceHandle<geo::Geometry>();
   fFFT = &*art::ServiceHandle<util::LArFFT>(); 
   if(ps.get<std::string>("CorrMode") == "mean") { fMode = 1; }
   else if(ps.get<std::string>("CorrMode") == "median") { fMode = 2; }
   else {
     std::cout << "PdspNoiseRemoval WARNING: correction set to mean value." << std::endl;
     fMode = 1;
   }
   auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataForJob();
   double binWidth = 1.0/(fFFT->FFTSize()*sampling_rate(clockData)*1.0e-6);
   fLowPassCoeffs.resize(fFFT->FFTSize() / 2 + 1);
   for(size_t i = 0; i < fLowPassCoeffs.size(); ++i) {
     float f = binWidth * i;
     fLowPassCoeffs[i] = 1.0 / sqrt(1.0 + pow(f/fCutoffFrequency, 8));
   }
   
   if( m_LogLevel >= 1 ) {
     cout << myname << "               LogLevel: " << m_LogLevel << endl;
     cout << myname << "    RemoveHighFrequency: " << fRemoveHighFrequency << endl;
     cout << myname << "         RemoveCoherent: " << fRemoveCoherent << endl;
     cout << myname << "        CutoffFrequency: " << fCutoffFrequency << endl;
     cout << myname << "      CoherentOffline16: " << fCoherentOffline16 << endl;
     cout << myname << "           CoherentDaq8: " << fCoherentDaq8  << endl;
     cout << myname << "          CoherentDaq16: " << fCoherentDaq16  << endl;
     cout << myname << "        CoherentFEMB128: " << fCoherentFEMB128  << endl;
     cout << myname << "CoherentOffline16Groups:  [";
     for(size_t i=0; i<fCoherentOffline16Groups.size(); i++) {
        cout<< fCoherentOffline16Groups.at(i) <<", ";    
     }
     cout << " ]" << endl;
     cout << myname << "CoherentDaq8Groups:  [";
     for(size_t i=0; i<fCoherentDaq8Groups.size(); i++) {
        cout<< fCoherentDaq8Groups.at(i) <<", "; 
     }
     cout << " ]" << endl;
     cout << myname << "CoherentDaq16Groups:  [";
     for(size_t i=0; i<fCoherentDaq16Groups.size(); i++) {
        cout<< fCoherentDaq16Groups.at(i) <<", ";        
     }
     cout << " ]" << endl;
     cout << myname << "CoherentFEMB128Groups:  [";
     for(size_t i=0; i<fCoherentFEMB128Groups.size(); i++) {
        cout<< fCoherentFEMB128Groups.at(i) <<", ";      
     }
     cout << " ]" << endl;
     cout << myname << "      UseBasicROIForCNR: " << fUseBasicROIForCNR  << endl;
     cout << myname << "      RoiStartThreshold: " << fRoiStartThreshold  << endl;
     cout << myname << "        RoiEndThreshold: " << fRoiEndThreshold  << endl;
     cout << myname << "              RoiPadLow: " << fRoiPadLow  << endl;
     cout << myname << "             RoiPadHigh: " << fRoiPadHigh  << endl;
   }  
 }

PdspNoiseRemoval::~PdspNoiseRemoval ( )

overridedefault

Member Function Documentation

std::vector< float > PdspNoiseRemoval::fftFlt	(	const std::vector< float > &	adc,
		const std::vector< float > &	coeffs
	)		const

private

Definition at line 194 of file PdspNoiseRemoval_tool.cc.

                                                                                                                    {
   std::vector< TComplex > ch_spectrum(fFFT->FFTSize() / 2 + 1);
   std::vector< float > ch_waveform(fFFT->FFTSize(), 0);
   size_t n_samples = adc.size();
   copyWaveform(adc, ch_waveform);
   fFFT->DoFFT(ch_waveform, ch_spectrum);
   for(size_t c = 0; c < coeffs.size(); ++c) {
     ch_spectrum[c] *= coeffs[c];
   }
   fFFT->DoInvFFT(ch_spectrum, ch_waveform);
   std::vector< float > flt_adc(n_samples);
   std::copy(ch_waveform.begin(), ch_waveform.begin()+n_samples, flt_adc.begin());
   return flt_adc;
 }

void PdspNoiseRemoval::fftFltInPlace	(	std::vector< float > &	adc,
		const std::vector< float > &	coeffs
	)		const

private

Definition at line 178 of file PdspNoiseRemoval_tool.cc.

                                                                                                       {
   const string myname = "PdspNoiseRemoval::fftFltInPlace: ";
   std::vector< TComplex > ch_spectrum(fFFT->FFTSize() / 2 + 1);
   std::vector< float > ch_waveform(fFFT->FFTSize(), 0);
   size_t n_samples = adc.size();
   if ( m_LogLevel >= 3 ) cout << myname << "N_ADC = " << adc.size() << ", N_WF = " << ch_waveform.size() << endl;
   copyWaveform(adc, ch_waveform);
   fFFT->DoFFT(ch_waveform, ch_spectrum);
   for(size_t c = 0; c < coeffs.size(); ++c) {
       ch_spectrum[c] *= coeffs[c]; 
   }
   fFFT->DoInvFFT(ch_spectrum, ch_waveform);
   std::copy(ch_waveform.begin(), ch_waveform.begin()+n_samples, adc.begin());
 }

size_t PdspNoiseRemoval::getDAQChan ( size_t LAr_chan )

staticprivate

Definition at line 396 of file PdspNoiseRemoval_tool.cc.

                                                    {
         // Get channel map
   art::ServiceHandle<dune::PdspChannelMapService> channelMap;
   size_t apa = channelMap->APAFromOfflineChannel(LAr_chan);
   size_t wib = channelMap->WIBFromOfflineChannel(LAr_chan);
   size_t femb = channelMap->FEMBFromOfflineChannel(LAr_chan);
   size_t fembChan = channelMap->FEMBChannelFromOfflineChannel(LAr_chan);
   size_t DaqChan = 2560*apa + 512* wib + 128* femb + fembChan; //does not depend on RCE or FELIX
   return DaqChan;
 }

std::vector< float > PdspNoiseRemoval::getMeanCorrection	(	const std::vector< unsigned int > &	channels,
		const AdcChannelDataMap &	datamap
	)		const

private

Definition at line 294 of file PdspNoiseRemoval_tool.cc.

                                                                                                                                        {
   size_t n_samples = datamap.begin()->second.samples.size();
   std::vector<size_t> ch_averaged(n_samples, 0);
   std::vector<float> correction(n_samples, 0);
   for(unsigned int ch : channels) {    
     auto iacd = datamap.find(ch);
     if(iacd == datamap.end()) continue;
     const AdcChannelData & acd = iacd->second; 
     if(acd.samples.size()>n_samples) {
       ch_averaged.resize(acd.samples.size(), 0.);       
       correction.resize(acd.samples.size(), 0.);
     }
     if(fUseBasicROIForCNR) {
       auto mask = roiMask(acd);  
       for(size_t s = 0; s < acd.samples.size(); ++s) {
         if (!mask[s]) { continue; }
         AdcFlag flag = (acd.flags.size()!=0 && s<acd.flags.size()) ? acd.flags[s] : AdcGood;
         if(flag != AdcGood) { continue; }
         correction[s] += acd.samples[s];
         ch_averaged[s]++;
       }
     }
     else {
       for(size_t s = 0; s < acd.samples.size(); ++s) {
               if(acd.signal[s]) { continue; }
         AdcFlag flag = (acd.flags.size()!=0 && s<acd.flags.size()) ? acd.flags[s] : AdcGood;
         if(flag != AdcGood) { continue; }
         correction[s] += acd.samples[s];
         ch_averaged[s]++;
       }
     }
   }
   for(size_t s = 0; s < correction.size(); ++s) {
     if(ch_averaged[s] > 0) { 
         correction[s] /= ch_averaged[s]; 
     }
   }
   return correction;
 }

std::vector< float > PdspNoiseRemoval::getMedianCorrection	(	const std::vector< unsigned int > &	channels,
		const AdcChannelDataMap &	datamap
	)		const

private

Definition at line 333 of file PdspNoiseRemoval_tool.cc.

                                                                                                                                          {
   size_t n_samples = datamap.begin()->second.samples.size();
   std::vector< std::vector<float> > samples(n_samples);
   for(unsigned int ch : channels) {
     auto iacd = datamap.find(ch);
     if(iacd == datamap.end()) continue;
     const AdcChannelData & acd = iacd->second;
     if(acd.samples.size()>n_samples) samples.resize(acd.samples.size());
     if(fUseBasicROIForCNR) {
       auto mask = roiMask(acd); 
       for(size_t s = 0; s < acd.samples.size(); ++s) {
         if (!mask[s]) { continue; }
         AdcFlag flag = (acd.flags.size()!=0 && s<acd.flags.size()) ? acd.flags[s] : AdcGood;
         if(flag != AdcGood) { continue; }
         samples[s].push_back(acd.samples[s]);
       }
     }
     else {
       for(size_t s = 0; s < acd.samples.size(); ++s) {
               if(acd.signal[s]) { continue; }
               AdcFlag flag = (acd.flags.size()!=0 && s<acd.flags.size()) ? acd.flags[s] : AdcGood;
         if(flag != AdcGood) { continue; }
         samples[s].push_back(acd.samples[s]);
       }
     }
   }
   std::vector<float> correction(samples.size());
   for(size_t s = 0; s < samples.size(); ++s) {
     size_t n = samples[s].size();
     if(n < 2) { correction[s] = 0; continue; }
     std::sort(samples[s].begin(), samples[s].end());
     if((n % 2) == 0) { correction[s] = 0.5 * (samples[s][n/2] + samples[s][(n/2)-1]); }
     else { correction[s] = samples[s][(n-1)/2]; }
   }
   return correction;
 }

bool PdspNoiseRemoval::has	(	const std::vector< size_t > &	v,
		size_t	idx
	)		const

inlineprivate

Definition at line 104 of file PdspNoiseRemoval.h.

                                                           {
     for (auto c : v) if (c == idx) return true;
     return false;
   }

GroupChannelMap PdspNoiseRemoval::makeGroupsByDAQChannels	(	size_t	gsize,
		const std::vector< size_t > &	gidx
	)		const

private

Definition at line 224 of file PdspNoiseRemoval_tool.cc.

                                                                                                               {
   GroupChannelMap groups;
   auto const & chStatus = art::ServiceHandle< lariov::ChannelStatusService >()->GetProvider();
   const unsigned int nchan = fGeometry->Nchannels();
   for(unsigned int ch = 0; ch < nchan; ++ch) {
     size_t g = getDAQChan(ch) / gsize;
     if(gidx.empty() || has(gidx, g)) {
       if(chStatus.IsPresent(ch) && !chStatus.IsBad(ch) && !chStatus.IsNoisy(ch)) {
         groups[g].push_back(ch); 
       }
     }
   }
   return groups;
 }

GroupChannelMap PdspNoiseRemoval::makeGroupsByFEMBPlaneType	(	size_t	gsize,
		const std::vector< size_t > &	gidx
	)		const

private

Definition at line 240 of file PdspNoiseRemoval_tool.cc.

                                                                                                                 {
   // Get channel map
   art::ServiceHandle<dune::PdspChannelMapService> channelMap;
   GroupChannelMap groups;
   auto const & chStatus = art::ServiceHandle< lariov::ChannelStatusService >()->GetProvider();
   const unsigned int nchan = fGeometry->Nchannels();
   for(unsigned int ch = 0; ch < nchan; ++ch) {
     //size_t g = ch / gsize;
     size_t g = getDAQChan(ch) / gsize;
     size_t plane = channelMap->PlaneFromOfflineChannel(ch);
     if(gidx.empty() || has(gidx, g) ) {
       if(chStatus.IsPresent(ch) && !chStatus.IsBad(ch) && !chStatus.IsNoisy(ch)) { 
         switch (plane) {
           case 0: groups[3*g].push_back(ch); 
             break;
           case 1: groups[3*g+1].push_back(ch); 
             break;
           case 2: groups[3*g+2].push_back(ch); 
                 break;
         }
       }
     }
   }
   return groups;
 }

GroupChannelMap PdspNoiseRemoval::makeGroupsByOfflineChannels	(	size_t	gsize,
		const std::vector< size_t > &	gidx
	)		const

private

Definition at line 210 of file PdspNoiseRemoval_tool.cc.

                                                                                                                   {
   GroupChannelMap groups;
   auto const & chStatus = art::ServiceHandle< lariov::ChannelStatusService >()->GetProvider();
   const unsigned int nchan = fGeometry->Nchannels();
   for(unsigned int ch = 0; ch < nchan; ++ch) {
     size_t g = ch / gsize;
     if(gidx.empty() || has(gidx, g)) {
       if(chStatus.IsPresent(ch) && !chStatus.IsBad(ch) && !chStatus.IsNoisy(ch)) { groups[g].push_back(ch); }
     }
   }
   return groups;
 }

void PdspNoiseRemoval::removeCoherent	(	const GroupChannelMap &	ch_groups,
		AdcChannelDataMap &	datamap
	)		const

private

Definition at line 267 of file PdspNoiseRemoval_tool.cc.

                                                                                                          {
   if(datamap.empty()) return;
   //PdspNoiseRemoval *th = const_cast <PdspNoiseRemoval *> (this); 
   //size_t n_samples = datamap.begin()->second.samples.size();
   for(const auto & entry : ch_groups) {   
     const auto & channels = entry.second;
     std::vector<float> correction;
     if(fMode == 1)  { // mean
       correction = getMeanCorrection(channels, datamap);
     }
     else if(fMode == 2)  { // median
       correction = getMedianCorrection(channels, datamap);
     }
     for(unsigned int ch : channels) {
       auto iacd = datamap.find(ch);
       if(iacd == datamap.end()) continue;
       AdcChannelData & acd = iacd->second;
       if(acd.samples.size() == 0) continue;
       if(acd.samples.size() > correction.size()) correction.resize(acd.samples.size(), 0.);
       for(size_t s = 0; s < acd.samples.size(); ++s) {
         acd.samples[s] -= correction[s];  
       }
     }
   }
 }

void PdspNoiseRemoval::removeHighFreq ( AdcChannelDataMap & datamap ) const

private

Definition at line 167 of file PdspNoiseRemoval_tool.cc.

 {
     auto const & chStatus = art::ServiceHandle< lariov::ChannelStatusService >()->GetProvider();
     for(auto & entry : datamap) {
       if ( chStatus.IsPresent(entry.first) && !chStatus.IsNoisy(entry.first) && entry.second.samples.size() ) {
         fftFltInPlace(entry.second.samples, fLowPassCoeffs);
       }
     }
 }

std::vector< bool > PdspNoiseRemoval::roiMask ( const AdcChannelData & adc ) const

private

Definition at line 371 of file PdspNoiseRemoval_tool.cc.

                                                                           {
   std::vector<bool> mask(acd.samples.size(), true);
   if ( acd.samples.size() == 0 ) return mask;
   auto acd_flt = fftFlt(acd.samples, fLowPassCoeffs);
   bool inroi = false;
   for (int i = 0; i < (int)acd_flt.size(); ++i) {
     auto sig = acd_flt[i];
     if (inroi){
       if (sig > fRoiEndThreshold || sig < -1.0*fRoiEndThreshold) { mask[i] = false; }
       else {
         for (int p = 0; p <= fRoiPadHigh; ++p) { if ((i + p) < (int)mask.size()) { mask[i + p] = false; } }
         inroi = false;
       }
     }
     else {
       if (sig > fRoiStartThreshold || sig < -1.0*fRoiStartThreshold) {
         for (int p = fRoiPadLow; p >= 0; --p) { if (i - p >= 0) { mask[i - p] = false; } }
         inroi = true;
       }
     }
   }
   return mask;
 }

DataMap PdspNoiseRemoval::updateMap ( AdcChannelDataMap & acds ) const

overridevirtual

Reimplemented from AdcChannelTool.

Definition at line 131 of file PdspNoiseRemoval_tool.cc.

                                                                  {
         const string myname = "PdspNoiseRemoval::updateMap: ";
         if( updateWithView() ) return viewMap(acds);
         DataMap ret(0);
   if (acds.size() == 0) {
     std::cout << myname << "WARNING: No channels found." << std::endl;
     ret.setStatus(1);
     return ret;
   }
 
   if(fRemoveHighFrequency) {
     removeHighFreq(acds);
   }
   if(fRemoveCoherent) {
     if(fCoherentOffline16) {
         auto ch_groups = makeGroupsByOfflineChannels(16, fCoherentOffline16Groups);
       removeCoherent(ch_groups, acds);
     }                 
           if(fCoherentFEMB128) {
         auto ch_groups = makeGroupsByFEMBPlaneType(128, fCoherentFEMB128Groups);
       removeCoherent(ch_groups, acds);
     }
           if(fCoherentDaq16) {
       auto ch_groups = makeGroupsByDAQChannels(16, fCoherentDaq16Groups);
       removeCoherent(ch_groups, acds);
     }
     if(fCoherentDaq8) {
       auto ch_groups = makeGroupsByDAQChannels(8, fCoherentDaq8Groups);
       removeCoherent(ch_groups, acds);
     }   
   }
   ret.setStatus(0);
   return ret;
 }

Member Data Documentation

bool PdspNoiseRemoval::fCoherentDaq16

private

Definition at line 65 of file PdspNoiseRemoval.h.

std::vector< size_t > PdspNoiseRemoval::fCoherentDaq16Groups

private

Definition at line 68 of file PdspNoiseRemoval.h.

bool PdspNoiseRemoval::fCoherentDaq8

private

Definition at line 65 of file PdspNoiseRemoval.h.

std::vector< size_t > PdspNoiseRemoval::fCoherentDaq8Groups

private

Definition at line 67 of file PdspNoiseRemoval.h.

bool PdspNoiseRemoval::fCoherentFEMB128

private

Definition at line 65 of file PdspNoiseRemoval.h.

std::vector< size_t > PdspNoiseRemoval::fCoherentFEMB128Groups

private

Definition at line 69 of file PdspNoiseRemoval.h.

bool PdspNoiseRemoval::fCoherentOffline16

private

Definition at line 65 of file PdspNoiseRemoval.h.

std::vector< size_t > PdspNoiseRemoval::fCoherentOffline16Groups

private

Definition at line 66 of file PdspNoiseRemoval.h.

float PdspNoiseRemoval::fCutoffFrequency

private

Definition at line 77 of file PdspNoiseRemoval.h.

util::LArFFT* PdspNoiseRemoval::fFFT

mutableprivate

Definition at line 81 of file PdspNoiseRemoval.h.

const geo::Geometry* PdspNoiseRemoval::fGeometry

private

Definition at line 80 of file PdspNoiseRemoval.h.

std::vector< float > PdspNoiseRemoval::fLowPassCoeffs

private

Definition at line 70 of file PdspNoiseRemoval.h.

int PdspNoiseRemoval::fMode

private

Definition at line 71 of file PdspNoiseRemoval.h.

bool PdspNoiseRemoval::fRemoveCoherent

private

Definition at line 64 of file PdspNoiseRemoval.h.

bool PdspNoiseRemoval::fRemoveHighFrequency

private

Definition at line 64 of file PdspNoiseRemoval.h.

float PdspNoiseRemoval::fRoiEndThreshold

private

Definition at line 74 of file PdspNoiseRemoval.h.

int PdspNoiseRemoval::fRoiPadHigh

private

Definition at line 76 of file PdspNoiseRemoval.h.

int PdspNoiseRemoval::fRoiPadLow

private

Definition at line 75 of file PdspNoiseRemoval.h.

float PdspNoiseRemoval::fRoiStartThreshold

private

Definition at line 73 of file PdspNoiseRemoval.h.

bool PdspNoiseRemoval::fUseBasicROIForCNR

private

Definition at line 72 of file PdspNoiseRemoval.h.

int PdspNoiseRemoval::m_LogLevel

private

Definition at line 63 of file PdspNoiseRemoval.h.

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

dunedataprep/dunedataprep/DataPrep/Tool/PdspNoiseRemoval.h
dunedataprep/dunedataprep/DataPrep/Tool/PdspNoiseRemoval_tool.cc

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation