util::SignalShaping Class Reference

#include "SignalShaping.h"

Public Member Functions
	SignalShaping ()
virtual	~SignalShaping ()
const std::vector< double > &	Response () const
const std::vector< double > &	Response_save () const
const std::vector< TComplex > &	ConvKernel () const
const std::vector< TComplex > &	Filter () const
const std::vector< TComplex > &	DeconvKernel () const
template<class T >
void	Convolute (std::vector< T > &func) const
template<class T >
void	Deconvolute (std::vector< T > &func) const
void	Reset ()
void	save_response ()
void	set_normflag (bool flag)
void	AddResponseFunction (const std::vector< double > &resp, bool ResetResponse=false)
void	ShiftResponseTime (double ticks)
void	SetPeakResponseTime (double tick)
void	AddFilterFunction (const std::vector< TComplex > &filt)
void	SetDeconvKernelPolarity (int pol)
void	LockResponse () const
void	CalculateDeconvKernel () const

Private Attributes
bool	fResponseLocked
bool	fFilterLocked
std::vector< double >	fResponse
std::vector< double >	fResponse_save
std::vector< TComplex >	fConvKernel
std::vector< TComplex >	fFilter
std::vector< TComplex >	fDeconvKernel
int	fDeconvKernelPolarity
bool	fNorm

Detailed Description

Definition at line 69 of file SignalShaping.h.

Constructor & Destructor Documentation

util::SignalShaping::SignalShaping

(

)

Definition at line 18 of file SignalShaping.cxx.

: fResponseLocked(false), fFilterLocked(false), fNorm(true) {}

util::SignalShaping::~SignalShaping ( )

virtual

Definition at line 23 of file SignalShaping.cxx.

{}

Member Function Documentation

void util::SignalShaping::AddFilterFunction

(

const std::vector< TComplex > &

filt

)

Definition at line 153 of file SignalShaping.cxx.

References fFilter, fFilterLocked, util::LArFFT::FFTSize(), filt, and n.

Referenced by set_normflag().

{
  // Make sure configuration is not locked.

  if (fFilterLocked) throw cet::exception("SignalShaping") << "Configuration locked.\n";

  // Get FFT service.

  art::ServiceHandle<util::LArFFT const> fft;

  // If this is the first filter function, just copy the filter function.
  // Otherwise, update the overall filter function.

  if (fFilter.size() == 0) {
    fFilter = filt;
    fFilter.resize(fft->FFTSize() / 2 + 1);
  }
  else {
    unsigned int n = std::min(fFilter.size(), filt.size());
    for (unsigned int i = 0; i < n; ++i)
      fFilter[i] *= filt[i];
    for (unsigned int i = n; i < fFilter.size(); ++i)
      fFilter[i] = 0.;
  }
}

void util::SignalShaping::AddResponseFunction	(	const std::vector< double > &	resp,
		bool	ResetResponse = false
	)

Definition at line 53 of file SignalShaping.cxx.

References util::LArFFT::DoFFT(), util::LArFFT::DoInvFFT(), fConvKernel, util::LArFFT::FFTSize(), fResponse, and fResponseLocked.

Referenced by set_normflag().

{
  // Make sure configuration is not locked.

  if (fResponseLocked) throw cet::exception("SignalShaping") << "Configuration locked.\n";

  // Get FFT service.

  art::ServiceHandle<util::LArFFT> fft;
  int nticks = fft->FFTSize();

  // Copy new response function into fResponse attribute, and pad or
  // truncate to correct size.

  fResponse = resp;
  fResponse.resize(nticks, 0.);

  // Is this the first response function?

  if (fConvKernel.size() == 0 || ResetResponse) {

    // This is the first response function.
    // Just calculate the fourier transform.

    fConvKernel.resize(nticks / 2 + 1);
    fft->DoFFT(fResponse, fConvKernel);
  }
  else {

    // Not the first response function.
    // Calculate the fourier transform of new response function.

    std::vector<TComplex> kern(nticks / 2 + 1);
    fft->DoFFT(fResponse, kern);

    // Update overall convolution kernel.

    if (kern.size() != fConvKernel.size()) {
      throw cet::exception("SignalShaping") << __func__ << ": inconsistent kernel size, "
                                            << kern.size() << " vs. " << fConvKernel.size();
    }
    for (unsigned int i = 0; i < kern.size(); ++i)
      fConvKernel[i] *= kern[i];

    // Recalculate overall response function.

    fft->DoInvFFT(fConvKernel, fResponse);
  }
}

void util::SignalShaping::CalculateDeconvKernel

(

)

const

Definition at line 233 of file SignalShaping.cxx.

References util::abs(), util::LArFFT::DoInvFFT(), fConvKernel, fDeconvKernel, fDeconvKernelPolarity, fFilter, fFilterLocked, util::LArFFT::FFTSize(), fNorm, fResponse, LockResponse(), and n.

Referenced by Deconvolute(), and set_normflag().

{
  // Make sure configuration is not locked.

  if (fFilterLocked) throw cet::exception("SignalShaping") << "Configuration locked.\n";

  // Lock response configuration.

  LockResponse();

  // Get FFT service.

  art::ServiceHandle<util::LArFFT> fft;

  // Make sure filter function has been configured.

  if (fFilter.size() == 0)
    throw cet::exception("SignalShaping") << "Filter function has not been configured.\n";

  // Make sure filter function has the correct size.
  // (Should always be the case if we get here.)

  unsigned int n = fft->FFTSize();
  if (2 * (fFilter.size() - 1) != n)
    if (fFilter.size() != fConvKernel.size()) {
      throw cet::exception("SignalShaping") << __func__ << ": inconsistent size, " << fFilter.size()
                                            << " vs. " << fConvKernel.size() << "\n";
    }

  // Calculate deconvolution kernel as the ratio of the
  // filter function and the convolution kernel.

  fDeconvKernel = fFilter;
  for (unsigned int i = 0; i < fDeconvKernel.size(); ++i) {
    if (std::abs(fConvKernel[i].Re()) <= 0.0001 && std::abs(fConvKernel[i].Im()) <= 0.0001) {
      fDeconvKernel[i] = 0.;
    }
    else {
      fDeconvKernel[i] /= fConvKernel[i];
    }
  }

  // Normalize the deconvolution kernel.

  // Calculate the unnormalized deconvoluted response
  // (inverse FFT of filter function).

  std::vector<double> deconv(n, 0.);
  fft->DoInvFFT(const_cast<std::vector<TComplex>&>(fFilter), deconv);

  if (fNorm) {
    // Find the peak value of the response
    // Should normally be at zero, but don't assume that.
    // Use DeconvKernelPolairty to find what to normalize to
    double peak_response = 0;
    if (fDeconvKernelPolarity == -1) peak_response = 4096;
    for (unsigned int i = 0; i < fResponse.size(); ++i) {
      if ((fResponse[i] > peak_response) and (fDeconvKernelPolarity == 1))
        peak_response = fResponse[i];
      else if ((fResponse[i] < peak_response) and (fDeconvKernelPolarity == -1))
        peak_response = fResponse[i];
    }
    if (fDeconvKernelPolarity == -1) peak_response *= -1;
    if (peak_response <= 0.) {
      throw cet::exception("SignalShaping")
        << __func__ << ": peak should always be positive (got " << peak_response << ")\n";
    }

    // Find the peak value of the deconvoluted response
    // Should normally be at zero, but don't assume that.

    double peak_deconv = 0.;
    for (unsigned int i = 0; i < deconv.size(); ++i) {
      if (deconv[i] > peak_deconv) peak_deconv = deconv[i];
    }
    if (peak_deconv <= 0.) {
      throw cet::exception("SignalShaping")
        << __func__ << ": deconvolution peak should always be positive (got " << peak_deconv
        << ")\n";
    }

    // Multiply the deconvolution kernel by a factor such that
    // (Peak of response) = (Peak of deconvoluted response).

    double ratio = peak_response / peak_deconv;
    for (unsigned int i = 0; i < fDeconvKernel.size(); ++i)
      fDeconvKernel[i] *= ratio;
  }
  // Set the lock flag.

  fFilterLocked = true;
}

const std::vector<TComplex>& util::SignalShaping::ConvKernel ( ) const

inline

Definition at line 78 of file SignalShaping.h.

References fConvKernel.

{ return fConvKernel; }

template<class T >

void util::SignalShaping::Convolute ( std::vector< T > &  func ) const

inline

Definition at line 171 of file SignalShaping.h.

References util::LArFFT::Convolute(), fConvKernel, util::LArFFT::FFTSize(), fResponseLocked, LockResponse(), and n.

Referenced by DeconvKernel().

{
  // Make sure response configuration is locked.
  if (!fResponseLocked) LockResponse();

  art::ServiceHandle<util::LArFFT> fft;

  // Make sure that time series has the correct size.
  if (int const n = func.size(); n != fft->FFTSize())
    throw cet::exception("SignalShaping") << "Bad time series size = " << n << "\n";

  fft->Convolute(func, const_cast<std::vector<TComplex>&>(fConvKernel));
}

const std::vector<TComplex>& util::SignalShaping::DeconvKernel ( ) const

inline

Definition at line 80 of file SignalShaping.h.

References Convolute(), Deconvolute(), fDeconvKernel, and Reset().

{ return fDeconvKernel; }

template<class T >

void util::SignalShaping::Deconvolute ( std::vector< T > &  func ) const

inline

Definition at line 188 of file SignalShaping.h.

References CalculateDeconvKernel(), util::LArFFT::Convolute(), fDeconvKernel, fFilterLocked, util::LArFFT::FFTSize(), and n.

Referenced by DeconvKernel().

{
  // Make sure deconvolution kernel is configured.
  if (!fFilterLocked) CalculateDeconvKernel();

  art::ServiceHandle<util::LArFFT> fft;

  // Make sure that time series has the correct size.
  if (int const n = func.size(); n != fft->FFTSize())
    throw cet::exception("SignalShaping") << "Bad time series size = " << n << "\n";

  fft->Convolute(func, fDeconvKernel);
}

const std::vector<TComplex>& util::SignalShaping::Filter ( ) const

inline

Definition at line 79 of file SignalShaping.h.

References fFilter.

{ return fFilter; }

void util::SignalShaping::LockResponse

(

)

const

Definition at line 197 of file SignalShaping.cxx.

References fConvKernel, util::LArFFT::FFTSize(), fResponse, fResponseLocked, and n.

Referenced by CalculateDeconvKernel(), Convolute(), and set_normflag().

{
  // Do nothing if the response is already locked.

  if (!fResponseLocked) {

    // Get FFT service.

    art::ServiceHandle<util::LArFFT const> fft;

    // Make sure response has been configured.

    if (fResponse.size() == 0)
      throw cet::exception("SignalShaping") << "Response has not been configured.\n";

    // Make sure response and convolution kernel have the correct
    // size (should always be the case if we get here).

    unsigned int n = fft->FFTSize();
    if (fResponse.size() != n)
      throw cet::exception("SignalShaping")
        << __func__ << ": inconsistent kernel size, " << fResponse.size() << " vs. " << n << "\n";
    if (2 * (fConvKernel.size() - 1) != n)
      throw cet::exception("SignalShaping")
        << __func__ << ": unexpected FFT size, " << n << " vs. expected "
        << (2 * (fConvKernel.size() - 1)) << "\n";

    // Set the lock flag.

    fResponseLocked = true;
  }
}

void util::SignalShaping::Reset

(

)

Definition at line 39 of file SignalShaping.cxx.

References fConvKernel, fDeconvKernel, fDeconvKernelPolarity, fFilter, fFilterLocked, fResponse, and fResponseLocked.

Referenced by DeconvKernel().

{
  fResponseLocked = false;
  fFilterLocked = false;
  fResponse.clear();
  fConvKernel.clear();
  fFilter.clear();
  fDeconvKernel.clear();
  //Set deconvolution polarity to + as default
  fDeconvKernelPolarity = +1;
}

const std::vector<double>& util::SignalShaping::Response ( ) const

inline

Definition at line 76 of file SignalShaping.h.

References fResponse.

{ return fResponse; }

const std::vector<double>& util::SignalShaping::Response_save ( ) const

inline

Definition at line 77 of file SignalShaping.h.

References fResponse_save.

{ return fResponse_save; }

void util::SignalShaping::save_response ( )

inline

Definition at line 100 of file SignalShaping.h.

References fResponse, and fResponse_save.

    {
      fResponse_save.clear();
      fResponse_save = fResponse;
    }

void util::SignalShaping::set_normflag ( bool  flag )

inline

Definition at line 105 of file SignalShaping.h.

References AddFilterFunction(), AddResponseFunction(), CalculateDeconvKernel(), fNorm, LockResponse(), SetDeconvKernelPolarity(), SetPeakResponseTime(), and ShiftResponseTime().

{ fNorm = flag; }

void util::SignalShaping::SetDeconvKernelPolarity

(

int

pol

)

Definition at line 181 of file SignalShaping.cxx.

References fDeconvKernelPolarity.

Referenced by set_normflag().

{

  if ((pol != 1) and (pol != -1)) {
    throw cet::exception("SignalShaping")
      << __func__ << ": DeconvKernelPolarity should be +1 or -1 (got " << pol
      << "). Setting to +1\n";
    fDeconvKernelPolarity = +1;
  }

  else
    fDeconvKernelPolarity = pol;
}

void util::SignalShaping::SetPeakResponseTime

(

double

tick

)

Definition at line 127 of file SignalShaping.cxx.

References util::LArFFT::FFTSize(), fResponse, fResponseLocked, util::LArFFT::PeakCorrelation(), and ShiftResponseTime().

Referenced by set_normflag().

{
  // Make sure configuration is not locked.

  if (fResponseLocked) throw cet::exception("SignalShaping") << "Configuration locked.\n";

  // Get FFT service.

  art::ServiceHandle<util::LArFFT> fft;

  // Construct a delta-function response centered at tick zero.

  std::vector<double> delta(fft->FFTSize(), 0.);
  delta[0] = 1.;

  // Figure out peak of current overall response.

  double peak = fft->PeakCorrelation(delta, fResponse);

  // Shift peak response to desired tick.

  ShiftResponseTime(tick - peak);
}

void util::SignalShaping::ShiftResponseTime

(

double

ticks

)

Definition at line 106 of file SignalShaping.cxx.

References util::LArFFT::DoInvFFT(), fConvKernel, fResponse, fResponseLocked, and util::LArFFT::ShiftData().

Referenced by set_normflag(), and SetPeakResponseTime().

{
  // Make sure configuration is not locked.

  if (fResponseLocked) throw cet::exception("SignalShaping") << "Configuration locked.\n";

  // Get FFT service.

  art::ServiceHandle<util::LArFFT> fft;

  // Update convolution kernel.

  fft->ShiftData(fConvKernel, ticks);

  // Recalculate overall response functiion.

  fft->DoInvFFT(fConvKernel, fResponse);
}

Member Data Documentation

std::vector<TComplex> util::SignalShaping::fConvKernel

private

Definition at line 149 of file SignalShaping.h.

Referenced by AddResponseFunction(), CalculateDeconvKernel(), ConvKernel(), Convolute(), LockResponse(), Reset(), and ShiftResponseTime().

std::vector<TComplex> util::SignalShaping::fDeconvKernel

mutableprivate

Definition at line 155 of file SignalShaping.h.

Referenced by CalculateDeconvKernel(), DeconvKernel(), Deconvolute(), and Reset().

int util::SignalShaping::fDeconvKernelPolarity

private

Definition at line 160 of file SignalShaping.h.

Referenced by CalculateDeconvKernel(), Reset(), and SetDeconvKernelPolarity().

std::vector<TComplex> util::SignalShaping::fFilter

private

Definition at line 152 of file SignalShaping.h.

Referenced by AddFilterFunction(), CalculateDeconvKernel(), Filter(), and Reset().

bool util::SignalShaping::fFilterLocked

mutableprivate

Definition at line 142 of file SignalShaping.h.

Referenced by AddFilterFunction(), CalculateDeconvKernel(), Deconvolute(), and Reset().

bool util::SignalShaping::fNorm

private

Definition at line 163 of file SignalShaping.h.

Referenced by CalculateDeconvKernel(), and set_normflag().

std::vector<double> util::SignalShaping::fResponse

private

Definition at line 145 of file SignalShaping.h.

Referenced by AddResponseFunction(), CalculateDeconvKernel(), LockResponse(), Reset(), Response(), save_response(), SetPeakResponseTime(), and ShiftResponseTime().

std::vector<double> util::SignalShaping::fResponse_save

private

Definition at line 146 of file SignalShaping.h.

Referenced by Response_save(), and save_response().

bool util::SignalShaping::fResponseLocked

mutableprivate

Definition at line 141 of file SignalShaping.h.

Referenced by AddResponseFunction(), Convolute(), LockResponse(), Reset(), SetPeakResponseTime(), and ShiftResponseTime().

---

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

• lardata/v09_16_03/source/lardata/Utilities/SignalShaping.h
• lardata/v09_16_03/source/lardata/Utilities/SignalShaping.cxx