FADC FIR (finite impulse response) filter. More...

#include <PndEmcFadcFilter.h>

Inheritance diagram for PndEmcFadcFilter:

Public Types
enum	type { arbitrary = 0, symmetric = 1, antisymmetric = -1 }

Public Member Functions
	PndEmcFadcFilter ()

virtual	~PndEmcFadcFilter ()

virtual void	Filter (const std::vector< Double_t > &in, std::vector< Double_t > &out) const

void	SetData (Double_t data[], Int_t i_size, Int_t i_offset)

Int_t	MinIndex () const

Int_t	MaxIndex () const

Int_t	Size () const

void	Convolute (const PndEmcFadcFilter &filt)

void	Convolute (const PndEmcFadcFilter &lhs, const PndEmcFadcFilter &rhs)

void	Clear ()

void	SetupMA (Int_t i_width)

void	SetupMWD (Int_t i_width, Double_t tau)

void	SetupMatchedFilter (Int_t i_width, PndEmcAbsPulseshape *pulseshape, Double_t sampleRate)

void	SetupBipolarTrapez (Int_t i_rise, Int_t i_flat, Int_t i_width)

void	SetupTrapez (Int_t i_rise, Int_t i_flat)

void	SetupBipolarTriangle (Int_t i_rise)

void	SetupDifferentiator (Int_t i_lag=0, Int_t i_width=1)

void	SetupDoubleDifferentiator (Int_t i_npos=1, Int_t i_nneg=1, Int_t i_nzero=0)

void	SetupPZDifferentiator (Int_t i_lag=0, Double_t d_fac=1.)

void	SetNormalizeFloating (Double_t d_norm=1.)

void	SetNormalizeInteger (Int_t i_shift=0)

std::vector< Double_t >	GetWeights () const

Private Attributes
std::vector< Double_t >	fCoeff

Int_t	fOffset

Int_t	fType

Bool_t	fIntegerize

Double_t	fNormFactor

Int_t	fShiftCount

Detailed Description

FADC FIR (finite impulse response) filter.

Definition at line 21 of file PndEmcFadcFilter.h.

Member Enumeration Documentation

enum PndEmcFadcFilter::type

Enumerator
arbitrary
symmetric
antisymmetric

Definition at line 24 of file PndEmcFadcFilter.h.

                   {
                 arbitrary = 0,
                 symmetric = 1,
                 antisymmetric = -1
         };

Constructor & Destructor Documentation

PndEmcFadcFilter::PndEmcFadcFilter ( )

Definition at line 29 of file PndEmcFadcFilter.cxx.

References fCoeff.

                                   :
     fCoeff(),
     fOffset(0),
     fType(arbitrary),
          fIntegerize(kFALSE),
          fNormFactor(1.),
     fShiftCount(0)
 {
   fCoeff.clear();
 }

PndEmcFadcFilter::~PndEmcFadcFilter ( )

virtual

Definition at line 40 of file PndEmcFadcFilter.cxx.

41 {}

Member Function Documentation

void PndEmcFadcFilter::Clear ( )

Definition at line 389 of file PndEmcFadcFilter.cxx.

References arbitrary, fCoeff, fOffset, and fType.

Referenced by Convolute(), SetData(), SetupBipolarTrapez(), SetupBipolarTriangle(), SetupDifferentiator(), SetupDoubleDifferentiator(), SetupMA(), SetupMatchedFilter(), SetupMWD(), SetupPZDifferentiator(), and SetupTrapez().

 {
         fCoeff.clear();
         fOffset = 0;
         fType   = arbitrary;
         return;
 }

void PndEmcFadcFilter::Convolute ( const PndEmcFadcFilter & filt )

Definition at line 83 of file PndEmcFadcFilter.cxx.

 {
         PndEmcFadcFilter tmp(*this);
         Convolute(tmp, filt);
         return;
 }

void PndEmcFadcFilter::Convolute	(	const PndEmcFadcFilter &	lhs,
		const PndEmcFadcFilter &	rhs
	)

Definition at line 91 of file PndEmcFadcFilter.cxx.

References arbitrary, Clear(), Double_t, fCoeff, fIntegerize, fNormFactor, fOffset, fShiftCount, fType, i, and Size().

 {
         const Double_t* p_lhs = &lhs.fCoeff[0];
         const Double_t* p_rhs = &rhs.fCoeff[0];
         Int_t i_nlhs = lhs.Size();
         Int_t i_nrhs = rhs.Size();
         Int_t i_size = i_nlhs + i_nrhs - 1;
 
         Clear();
         fCoeff.resize(i_size);
 
         for (Int_t i = 0; i < i_size; i++) {
                 Double_t f_sum = 0.;
                 for (Int_t j = 0; j < i_nlhs; j++) {
                         Int_t k = j - i + i_nrhs - 1;
                         Double_t f_rhs = (k >= 0 && k < i_nrhs) ? p_rhs[k] : 0.;
                         f_sum += p_lhs[j] * f_rhs;
                 }
                 fCoeff[i] = f_sum;
         }
 
         fType = lhs.fType * rhs.fType;
         if (fType == arbitrary) {
                 fOffset = (i_size)/2;               // ???
         } else {
                 fOffset = (i_size)/2;    
         }
 
         fIntegerize = lhs.fIntegerize & rhs.fIntegerize;
         fShiftCount = (fIntegerize) ? lhs.fShiftCount + rhs.fShiftCount : 0;
         fNormFactor = lhs.fNormFactor * rhs.fNormFactor;
 
         return;
 }

void PndEmcFadcFilter::Filter	(	const std::vector< Double_t > &	in,
		std::vector< Double_t > &	out
	)		const

virtual

Definition at line 44 of file PndEmcFadcFilter.cxx.

References Double_t, fCoeff, fIntegerize, fNormFactor, i, MaxIndex(), and MinIndex().

Referenced by PndEmcPSATrapDigiFilter::Process(), PndEmcPSAMatchedDigiFilter::Process(), and testFilter().

 {
         Int_t i_size = in.size();
         if (i_size == 0) {
                 out.clear();
                 return;
         }
 
         Int_t i_nlpad = -MinIndex();
         Int_t i_nrpad =  MaxIndex();
         Int_t i_ntab  =  fCoeff.size();
         std::vector<Double_t> temp(i_size + i_nlpad + i_nrpad);
 
         Double_t* p_data = &temp[0];
         for (Int_t i = 0; i < i_nlpad; i++) *p_data++ = in[0];
         for (Int_t i = 0; i < i_size;  i++) *p_data++ = in[i];
         for (Int_t i = 0; i < i_nrpad; i++) *p_data++ = in[i_size-1];
 
         out.resize(i_size);
 
         p_data = &temp[0];
         for (Int_t i = 0; i < i_size; i++) {
                 const Double_t* p_d = p_data;
                 const Double_t* p_c = &fCoeff[0];
                 Double_t  d_sum = 0.;
 
                 for (Int_t j = 0; j < i_ntab; j++)
                         d_sum += *p_c++ * *p_d++;
                 p_data ++;
                 
                 d_sum *= fNormFactor;
                 if (fIntegerize) d_sum = floor(d_sum);
                 out[i] = d_sum;
         }
 
         return;
 }

std::vector<Double_t> PndEmcFadcFilter::GetWeights ( ) const

inline

Definition at line 58 of file PndEmcFadcFilter.h.

References fCoeff.

58 {return fCoeff;}

PndEmcFadcFilter::fCoeff

std::vector< Double_t > fCoeff

Definition: PndEmcFadcFilter.h:61

Int_t PndEmcFadcFilter::MaxIndex ( ) const

Definition at line 378 of file PndEmcFadcFilter.cxx.

References fCoeff, and fOffset.

Referenced by Filter().

 {
         return fCoeff.size() - 1 - fOffset;
 }

Int_t PndEmcFadcFilter::MinIndex ( ) const

Definition at line 372 of file PndEmcFadcFilter.cxx.

References fOffset.

Referenced by Filter().

 {
         return -fOffset;
 }

void PndEmcFadcFilter::SetData	(	Double_t	data[],
		Int_t	i_size,
		Int_t	i_offset
	)

Definition at line 128 of file PndEmcFadcFilter.cxx.

References antisymmetric, arbitrary, Clear(), Double_t, fCoeff, fOffset, fType, i, and symmetric.

Referenced by testFilter().

 {
         Clear();
         fCoeff.resize(i_size);
         for (Int_t i = 0; i < i_size; i++) fCoeff[i] = data[i];
 
         if (i_size == 1) {
                 fType   = symmetric;
         } else {
                 Int_t i_nsym  = 0;
                 Int_t i_nasym = 0;
                 Int_t i_size2 = i_size/2;
                 for (Int_t i = 0; i < i_size2; i++) {
                         Double_t f_left  = data[i];
                         Double_t f_right = data[i_size-i-1];
                         if (f_left ==  f_right) i_nsym  += 1;
                         if (f_left == -f_right) i_nasym += 1;
                 }
                 fType = arbitrary;
                 if (i_nsym  == i_size2) fType = symmetric;
                 if (i_nasym == i_size2) fType = antisymmetric;
         }
 
         if (fType != arbitrary || i_offset < 0)
                  i_offset = i_size/2;
         
         fOffset = i_offset;
   
         return;
 }

void PndEmcFadcFilter::SetNormalizeFloating ( Double_t d_norm = 1. )

Definition at line 353 of file PndEmcFadcFilter.cxx.

References fIntegerize, fNormFactor, and fShiftCount.

 {
         fIntegerize = kFALSE;
         fShiftCount = 0;
         fNormFactor = d_norm;
         return;
 }

void PndEmcFadcFilter::SetNormalizeInteger ( Int_t i_shift = 0 )

Definition at line 362 of file PndEmcFadcFilter.cxx.

References fIntegerize, fNormFactor, fShiftCount, and i.

 {
         fIntegerize = kTRUE;
         fShiftCount = i_shift;
         fNormFactor = 1.;
         for (Int_t i = 0; i < i_shift; i++) fNormFactor *= 0.5;
         return;
 }

void PndEmcFadcFilter::SetupBipolarTrapez	(	Int_t	i_rise,
		Int_t	i_flat,
		Int_t	i_width
	)

Definition at line 217 of file PndEmcFadcFilter.cxx.

References Clear(), fCoeff, fType, i, and symmetric.

 {
         Int_t i_size = 2*i_rise + 2*i_flat+i_width+1;
         Clear();
 
         fCoeff.resize(i_size);
         fType   = symmetric;
         
         for (Int_t i = 0; i < i_rise; i++) {
                 fCoeff[i]          = i;
                 fCoeff[i_size-i-1]   = -i;
         }
         
         for (Int_t i = i_rise; i < (i_rise+i_flat); i++)
         {
                 fCoeff[i] = i_rise;
                 fCoeff[i_flat+i_width+i+1] = -i_rise;
         }
         
         for (Int_t i = (i_rise+i_flat); i <= (i_rise+i_flat+i_width); i++) {
                 fCoeff[i]          = i_rise-2*i_rise/i_width*(i-i_rise-i_width);
         }
         
         return;
 }

void PndEmcFadcFilter::SetupBipolarTriangle ( Int_t i_rise )

Definition at line 264 of file PndEmcFadcFilter.cxx.

References antisymmetric, Clear(), fCoeff, fOffset, fType, and i.

 {
         Int_t i_size = 4*i_rise + 1;
         Clear();
 
         fOffset = 2*i_rise;
         fCoeff.resize(i_size);
         fType   = antisymmetric;
 
         for (Int_t i = 0; i <= i_rise; i++) {
                 fCoeff[i]          =  i;
                 fCoeff[fOffset-i] =  i;
                 fCoeff[fOffset+i] = -i;
                 fCoeff[i_size-i-1] = -i;
         }
 
         return;
 }

void PndEmcFadcFilter::SetupDifferentiator	(	Int_t	i_lag = `0`,
		Int_t	i_width = `1`
	)

Definition at line 284 of file PndEmcFadcFilter.cxx.

References antisymmetric, Clear(), fCoeff, fOffset, fType, and i.

 {
         Int_t i_size = i_lag + 2*i_width;
         Clear();
 
         fOffset = (i_size)/2;
         fCoeff.resize(i_size);
         fType   = antisymmetric;
 
         for (Int_t i = 0; i < i_size; i++) fCoeff[i] = 0;
         for (Int_t i = 0; i < i_width; i++) {
                 fCoeff[i]          = -1.;
                 fCoeff[i_size-i-1] =  1.;
         }
 
         return;
 }

void PndEmcFadcFilter::SetupDoubleDifferentiator	(	Int_t	i_npos = `1`,
		Int_t	i_nneg = `1`,
		Int_t	i_nzero = `0`
	)

Definition at line 303 of file PndEmcFadcFilter.cxx.

References Clear(), fCoeff, fOffset, fType, i, max(), and symmetric.

 {
         Int_t i_size = i_npos + 2*(i_nzero + i_nneg);
         Clear();
 
         fOffset = (i_size)/2;
         fCoeff.resize(i_size);
         fType   = symmetric;
 
         Int_t i_apos = 2*i_nneg;
         Int_t i_aneg = i_npos;
         Int_t i_div  = 1;
         for (Int_t i = 2; i < max(i_apos,i_aneg); i++) {
                 if (i_apos%i == 0 && i_aneg%i == 0) i_div = i;
         }
         i_apos /= i_div;
         i_aneg /= i_div;
 
         for (Int_t i = 0; i < i_size; i++) fCoeff[i] = i_apos;
         for (Int_t i = 0; i < i_nneg; i++) {
                 fCoeff[i]          = -i_aneg;
                 fCoeff[i_size-i-1] = -i_aneg;
         }
         for (Int_t i = i_nneg; i < i_nneg+i_nzero; i++) {
                 fCoeff[i]          = 0.;
                 fCoeff[i_size-i-1] = 0.;
         }
 
         return;
 }

void PndEmcFadcFilter::SetupMA ( Int_t i_width )

Definition at line 160 of file PndEmcFadcFilter.cxx.

References Clear(), fCoeff, fType, i, and symmetric.

 {
         Int_t i_size = i_width;
         Clear();
         fCoeff.resize(i_size);
         fType   = symmetric;
         
         for (Int_t i = 0; i < i_size; i++) {
                 fCoeff[i] = 1./i_width;
         }
 
         return;
 }

void PndEmcFadcFilter::SetupMatchedFilter	(	Int_t	i_width,
		PndEmcAbsPulseshape *	pulseshape,
		Double_t	sampleRate
	)

Definition at line 193 of file PndEmcFadcFilter.cxx.

References arbitrary, Clear(), Double_t, fCoeff, fType, i, t, val, and PndEmcAbsPulseshape::value().

Referenced by PndEmcPSAMatchedDigiFilter::Process().

 {
         Int_t i_size = i_width;
         Clear();
         fCoeff.resize(i_size);
         fType   = arbitrary;
         
         Double_t amplitude=1.;
         Double_t t;
         Double_t val=0;
         
         for (  int i=0;i<i_size;i++)
         {
                 t= i/sampleRate;
                 val=pulseshape->value(t,amplitude,0.);
                 fCoeff[i]=val;
         }
         
         std::reverse(fCoeff.begin(), fCoeff.end());
         
         return;
         
 } 

void PndEmcFadcFilter::SetupMWD	(	Int_t	i_width,
		Double_t	tau
	)

Definition at line 175 of file PndEmcFadcFilter.cxx.

References arbitrary, Clear(), fCoeff, fType, and i.

 {
         Int_t i_size = i_width;
         Clear();
         fCoeff.resize(i_size);
         fType   = arbitrary;
         
         fCoeff[0]=1;
         fCoeff[i_size-1]=-(1-1./tau);
         
         for (Int_t i = 1; i < i_size-1; i++) {
                 fCoeff[i] = 1./tau;
         }
 
         return;
 }

void PndEmcFadcFilter::SetupPZDifferentiator	(	Int_t	i_lag = `0`,
		Double_t	d_fac = `1.`
	)

Definition at line 336 of file PndEmcFadcFilter.cxx.

References arbitrary, Clear(), fCoeff, fOffset, fType, and i.

 {
         Int_t i_size = i_lag + 2;
         Clear();
 
         fOffset = (i_size)/2;
         fCoeff.resize(i_size);
         fType   = arbitrary;
 
         for (Int_t i = 0; i < i_size; i++) fCoeff[i] = 0.;
         fCoeff[0]        = -d_fac;
         fCoeff[i_size-1] = 1.;
 
         return;
 }

void PndEmcFadcFilter::SetupTrapez	(	Int_t	i_rise,
		Int_t	i_flat
	)

Definition at line 244 of file PndEmcFadcFilter.cxx.

References Clear(), fCoeff, fOffset, fType, i, and symmetric.

Referenced by PndEmcPSATrapDigiFilter::Process(), and testFilter().

 {
         Int_t i_size = 2*i_rise + i_flat;
         Clear();
 
         fOffset = (i_size)/2;
         fCoeff.resize(i_size);
         fType   = symmetric;
 
         for (Int_t i = 0; i < i_size; i++) fCoeff[i] = i_rise+1;
         for (Int_t i = 0; i < i_rise; i++) {
                 fCoeff[i]          = i+1;
                 fCoeff[i_size-i-1] = i+1;
         }
 
         return;
 }