#include "LArFFT.h"

Public Member Functions
	LArFFT (fhicl::ParameterSet const &pset, art::ActivityRegistry &reg)

	~LArFFT ()

template<class T >
void	DoFFT (std::vector< T > &input, std::vector< TComplex > &output)

template<class T >
void	DoInvFFT (std::vector< TComplex > &input, std::vector< T > &output)

template<class T >
void	Deconvolute (std::vector< T > &input, std::vector< T > &respFunc)

template<class T >
void	Deconvolute (std::vector< T > &input, std::vector< TComplex > &kern)

template<class T >
void	Convolute (std::vector< T > &input, std::vector< T > &respFunc)

template<class T >
void	Convolute (std::vector< T > &input, std::vector< TComplex > &kern)

template<class T >
void	Correlate (std::vector< T > &input, std::vector< T > &respFunc)

template<class T >
void	Correlate (std::vector< T > &input, std::vector< TComplex > &kern)

template<class T >
void	AlignedSum (std::vector< T > &input, std::vector< T > &output, bool add=true)

void	ShiftData (std::vector< TComplex > &input, double shift)

template<class T >
void	ShiftData (std::vector< T > &input, double shift)

template<class T >
T	PeakCorrelation (std::vector< T > &shape1, std::vector< T > &shape2)

int	FFTSize () const

std::string	FFTOptions () const

int	FFTFitBins () const

void	ReinitializeFFT (int, std::string, int)

Private Member Functions
void	InitializeFFT ()

void	resetSizePerRun (art::Run const &)

Private Attributes
int	fSize

int	fFreqSize

std::string	fOption

int	fFitBins

TF1 *	fPeakFit

TH1D *	fConvHist

std::vector< TComplex >	fCompTemp

std::vector< TComplex >	fKern

TFFTRealComplex *	fFFT
	object to do FFT More...

TFFTComplexReal *	fInverseFFT
	object to do Inverse FF More...

Detailed Description

Definition at line 26 of file LArFFT.h.

Constructor & Destructor Documentation

util::LArFFT::LArFFT	(	fhicl::ParameterSet const &	pset,
		art::ActivityRegistry &	reg
	)

Definition at line 18 of file LArFFT.cc.

References fSize, InitializeFFT(), resetSizePerRun(), and art::ActivityRegistry::sPreBeginRun.

   : fSize(pset.get<int>("FFTSize", 0))
   , fOption(pset.get<std::string>("FFTOption"))
   , fFitBins(pset.get<int>("FitBins"))
 {
   // Default to the readout window size if the user didn't input
   // a specific size
   if (fSize <= 0) {
     // Creating a service handle to DetectorPropertiesService not only
     // creates the service if it doesn't exist, it also guarantees
     // that its callbacks are invoked before any of LArFFT's callbacks
     // are invoked.
     fSize = art::ServiceHandle<detinfo::DetectorPropertiesService const>()
               ->DataForJob()
               .ReadOutWindowSize();
     reg.sPreBeginRun.watch(this, &util::LArFFT::resetSizePerRun);
   }
   InitializeFFT();
 }

util::LArFFT::~LArFFT ( )

Definition at line 76 of file LArFFT.cc.

References fConvHist, fFFT, fInverseFFT, and fPeakFit.

 {
   delete fFFT;
   delete fInverseFFT;
   delete fPeakFit;
   delete fConvHist;
 }

Member Function Documentation

template<class T >

void util::LArFFT::AlignedSum	(	std::vector< T > &	input,
		std::vector< T > &	output,
		bool	add = `true`
	)

inline

Definition at line 241 of file LArFFT.h.

References fSize, PeakCorrelation(), and ShiftData().

Referenced by caldata::CalWireAna::analyze().

 {
   double shift = PeakCorrelation(shape1, shape2);
 
   ShiftData(shape1, shift);
 
   if (add)
     for (int i = 0; i < fSize; i++)
       shape1[i] += shape2[i];
 
   return;
 }

template<class T >

void util::LArFFT::Convolute	(	std::vector< T > &	input,
		std::vector< T > &	respFunc
	)

inline

Definition at line 170 of file LArFFT.h.

References DoFFT(), DoInvFFT(), fCompTemp, fFreqSize, and fKern.

Referenced by util::SignalShaping::Convolute(), util::SignalShaping::Deconvolute(), caldata::CalWire::produce(), and caldata::CalWireT962::produce().

 {
   DoFFT(shape1, fKern);
   DoFFT(shape2, fCompTemp);
 
   for (int i = 0; i < fFreqSize; i++)
     fCompTemp[i] *= fKern[i];
 
   DoInvFFT(fCompTemp, shape1);
 
   return;
 }

template<class T >

void util::LArFFT::Convolute	(	std::vector< T > &	input,
		std::vector< TComplex > &	kern
	)

inline

Definition at line 189 of file LArFFT.h.

References DoFFT(), DoInvFFT(), fCompTemp, and fFreqSize.

 {
   DoFFT(input, fCompTemp);
 
   for (int i = 0; i < fFreqSize; i++)
     fCompTemp[i] *= kern[i];
 
   DoInvFFT(fCompTemp, input);
 
   return;
 }

template<class T >

void util::LArFFT::Correlate	(	std::vector< T > &	input,
		std::vector< T > &	respFunc
	)

inline

Definition at line 204 of file LArFFT.h.

References DoFFT(), DoInvFFT(), fCompTemp, fFreqSize, and fKern.

Referenced by PeakCorrelation().

 {
   DoFFT(shape1, fKern);
   DoFFT(shape2, fCompTemp);
 
   for (int i = 0; i < fFreqSize; i++)
     fCompTemp[i] *= TComplex::Conjugate(fKern[i]);
 
   DoInvFFT(fCompTemp, shape1);
 
   return;
 }

template<class T >

void util::LArFFT::Correlate	(	std::vector< T > &	input,
		std::vector< TComplex > &	kern
	)

inline

Definition at line 223 of file LArFFT.h.

References DoFFT(), DoInvFFT(), fCompTemp, and fFreqSize.

 {
   DoFFT(input, fCompTemp);
 
   for (int i = 0; i < fFreqSize; i++)
     fCompTemp[i] *= TComplex::Conjugate(kern[i]);
 
   DoInvFFT(fCompTemp, input);
 
   return;
 }

template<class T >

void util::LArFFT::Deconvolute	(	std::vector< T > &	input,
		std::vector< T > &	respFunc
	)

inline

Definition at line 135 of file LArFFT.h.

References DoFFT(), DoInvFFT(), fCompTemp, fFreqSize, and fKern.

 {
   DoFFT(respFunction, fKern);
   DoFFT(input, fCompTemp);
 
   for (int i = 0; i < fFreqSize; i++)
     fCompTemp[i] /= fKern[i];
 
   DoInvFFT(fCompTemp, input);
 
   return;
 }

template<class T >

void util::LArFFT::Deconvolute	(	std::vector< T > &	input,
		std::vector< TComplex > &	kern
	)

inline

Definition at line 154 of file LArFFT.h.

References DoFFT(), DoInvFFT(), fCompTemp, and fFreqSize.

 {
   DoFFT(input, fCompTemp);
 
   for (int i = 0; i < fFreqSize; i++)
     fCompTemp[i] /= kern[i];
 
   DoInvFFT(fCompTemp, input);
 
   return;
 }

template<class T >

void util::LArFFT::DoFFT	(	std::vector< T > &	input,
		std::vector< TComplex > &	output
	)

inline

Definition at line 95 of file LArFFT.h.

References fFFT, and fFreqSize.

Referenced by util::SignalShaping::AddResponseFunction(), caldata::CalWireAna::analyze(), Convolute(), detsim::SimWire::ConvoluteResponseFunctions(), Correlate(), Deconvolute(), and ShiftData().

 {
   double real = 0.;      //real value holder
   double imaginary = 0.; //imaginary value hold
 
   // set the points
   for (size_t p = 0; p < input.size(); ++p)
     fFFT->SetPoint(p, input[p]);
 
   fFFT->Transform();
 
   for (int i = 0; i < fFreqSize; ++i) {
     fFFT->GetPointComplex(i, real, imaginary);
     output[i] = TComplex(real, imaginary);
   }
 
   return;
 }

template<class T >

void util::LArFFT::DoInvFFT	(	std::vector< TComplex > &	input,
		std::vector< T > &	output
	)

inline

Definition at line 117 of file LArFFT.h.

References fFreqSize, fInverseFFT, and fSize.

Referenced by util::SignalShaping::AddResponseFunction(), util::SignalShaping::CalculateDeconvKernel(), Convolute(), detsim::SimWire::ConvoluteResponseFunctions(), Correlate(), Deconvolute(), detsim::SimWire::GenNoise(), ShiftData(), and util::SignalShaping::ShiftResponseTime().

 {
   for (int i = 0; i < fFreqSize; ++i)
     fInverseFFT->SetPointComplex(i, input[i]);
 
   fInverseFFT->Transform();
   double factor = 1.0 / (double)fSize;
 
   for (int i = 0; i < fSize; ++i)
     output[i] = factor * fInverseFFT->GetPointReal(i, false);
 
   return;
 }

int util::LArFFT::FFTFitBins ( ) const

inline

Definition at line 68 of file LArFFT.h.

References fFitBins, and ReinitializeFFT().

68 { return fFitBins; }

util::LArFFT::fFitBins

int fFitBins

Definition: LArFFT.h:76

std::string util::LArFFT::FFTOptions ( ) const

inline

Definition at line 67 of file LArFFT.h.

References fOption.

67 { return fOption; }

util::LArFFT::fOption

std::string fOption

Definition: LArFFT.h:75

int util::LArFFT::FFTSize ( ) const

inline

Definition at line 66 of file LArFFT.h.

References fSize.

Referenced by util::SignalShaping::AddFilterFunction(), util::SignalShaping::AddResponseFunction(), detsim::WienerFilterAna::analyze(), caldata::CalWireAna::analyze(), detsim::WienerFilterAna::beginJob(), detsim::SimWire::beginJob(), util::SignalShaping::CalculateDeconvKernel(), util::SignalShaping::Convolute(), util::SignalShaping::Deconvolute(), util::SignalShaping::LockResponse(), caldata::CalWire::produce(), caldata::CalWireT962::produce(), and util::SignalShaping::SetPeakResponseTime().

66 { return fSize; }

util::LArFFT::fSize

int fSize

Definition: LArFFT.h:73

void util::LArFFT::InitializeFFT ( )

private

Definition at line 48 of file LArFFT.cc.

References fCompTemp, fConvHist, fFFT, fFitBins, fFreqSize, fInverseFFT, fKern, fOption, fPeakFit, and fSize.

Referenced by LArFFT(), and ReinitializeFFT().

 {
   int i;
   for (i = 1; i < fSize; i *= 2) {}
   fSize = i;
   fFreqSize = fSize / 2 + 1;
 
   // allocate and setup Transform objects
   fFFT = new TFFTRealComplex(fSize, false);
   fInverseFFT = new TFFTComplexReal(fSize, false);
 
   int dummy[1] = {0};
   // appears to be dummy argument from root page
   fFFT->Init(fOption.c_str(), -1, dummy);
   fInverseFFT->Init(fOption.c_str(), 1, dummy);
 
   fPeakFit = new TF1("fPeakFit", "gaus"); //allocate function used for peak fitting
   fConvHist = new TH1D("fConvHist",
                        "Convolution Peak Data",
                        fFitBins,
                        0,
                        fFitBins); //allocate histogram for peak fitting
   //allocate other data vectors
   fCompTemp.resize(fFreqSize);
   fKern.resize(fFreqSize);
 }

template<class T >

T util::LArFFT::PeakCorrelation	(	std::vector< T > &	shape1,
		std::vector< T > &	shape2
	)

inline

Definition at line 270 of file LArFFT.h.

References Correlate(), DECLARE_ART_SERVICE, fConvHist, fFitBins, fPeakFit, and fSize.

Referenced by AlignedSum(), detsim::SimWire::ConvoluteResponseFunctions(), and util::SignalShaping::SetPeakResponseTime().

 {
   fConvHist->Reset("ICE");
   std::vector<T> holder = shape1;
   Correlate(holder, shape2);
 
   int maxT = max_element(holder.begin(), holder.end()) - holder.begin();
   float startT = maxT - fFitBins / 2;
   int offset = 0;
 
   for (int i = 0; i < fFitBins; i++) {
     if (startT + i < 0)
       offset = fSize;
     else if (startT + i > fSize)
       offset = -fSize;
     else
       offset = 0;
     fConvHist->Fill(i, holder[i + startT + offset]);
   }
 
   fPeakFit->SetParameters(fConvHist->GetMaximum(), fFitBins / 2, fFitBins / 2);
   fConvHist->Fit(fPeakFit, "QWNR", "", 0, fFitBins);
   return fPeakFit->GetParameter(1) + startT;
 }

void util::LArFFT::ReinitializeFFT	(	int	size,
		std::string	option,
		int	fitbins
	)

Definition at line 85 of file LArFFT.cc.

References fConvHist, fFFT, fFitBins, fInverseFFT, fOption, fPeakFit, fSize, InitializeFFT(), and util::size().

Referenced by FFTFitBins(), and resetSizePerRun().

 {
   //delete these, which will be remade
   delete fFFT;
   delete fInverseFFT;
   delete fPeakFit;
   delete fConvHist;
 
   //set members
   fSize = size;
   fOption = option;
   fFitBins = fitbins;
 
   //now initialize
   InitializeFFT();
 }

void util::LArFFT::resetSizePerRun ( art::Run const & )

private

Definition at line 39 of file LArFFT.cc.

References fFitBins, fOption, fSize, and ReinitializeFFT().

Referenced by LArFFT().

 {
   fSize = art::ServiceHandle<detinfo::DetectorPropertiesService const>()
             ->DataForJob()
             .ReadOutWindowSize();
   ReinitializeFFT(fSize, fOption, fFitBins);
 }

void util::LArFFT::ShiftData	(	std::vector< TComplex > &	input,
		double	shift
	)

Definition at line 116 of file LArFFT.cc.

References fFreqSize, and fSize.

Referenced by AlignedSum(), detsim::SimWire::ConvoluteResponseFunctions(), ShiftData(), and util::SignalShaping::ShiftResponseTime().

 {
   double factor = -2.0 * TMath::Pi() * shift / (double)fSize;
 
   for (int i = 0; i < fFreqSize; i++)
     input[i] *= TComplex::Exp(TComplex(0, factor * (double)i));
 
   return;
 }

template<class T >

void util::LArFFT::ShiftData	(	std::vector< T > &	input,
		double	shift
	)

inline

Definition at line 257 of file LArFFT.h.

References DoFFT(), DoInvFFT(), fCompTemp, and ShiftData().

 {
   DoFFT(input, fCompTemp);
   ShiftData(fCompTemp, shift);
   DoInvFFT(fCompTemp, input);
 
   return;
 }

Member Data Documentation

std::vector<TComplex> util::LArFFT::fCompTemp

private

Definition at line 79 of file LArFFT.h.

Referenced by Convolute(), Correlate(), Deconvolute(), InitializeFFT(), and ShiftData().

TH1D* util::LArFFT::fConvHist

private

Definition at line 78 of file LArFFT.h.

Referenced by InitializeFFT(), PeakCorrelation(), ReinitializeFFT(), and ~LArFFT().

TFFTRealComplex* util::LArFFT::fFFT

private

object to do FFT

Definition at line 82 of file LArFFT.h.

Referenced by DoFFT(), InitializeFFT(), ReinitializeFFT(), and ~LArFFT().

int util::LArFFT::fFitBins

private

Definition at line 76 of file LArFFT.h.

Referenced by FFTFitBins(), InitializeFFT(), PeakCorrelation(), ReinitializeFFT(), and resetSizePerRun().

int util::LArFFT::fFreqSize

private

Definition at line 74 of file LArFFT.h.

Referenced by Convolute(), Correlate(), Deconvolute(), DoFFT(), DoInvFFT(), InitializeFFT(), and ShiftData().

TFFTComplexReal* util::LArFFT::fInverseFFT

private

object to do Inverse FF

Definition at line 83 of file LArFFT.h.

Referenced by DoInvFFT(), InitializeFFT(), ReinitializeFFT(), and ~LArFFT().

std::vector<TComplex> util::LArFFT::fKern

private

Definition at line 80 of file LArFFT.h.

Referenced by Convolute(), Correlate(), Deconvolute(), and InitializeFFT().

std::string util::LArFFT::fOption

private

Definition at line 75 of file LArFFT.h.

Referenced by FFTOptions(), InitializeFFT(), ReinitializeFFT(), and resetSizePerRun().

TF1* util::LArFFT::fPeakFit

private

Definition at line 77 of file LArFFT.h.

Referenced by InitializeFFT(), PeakCorrelation(), ReinitializeFFT(), and ~LArFFT().

int util::LArFFT::fSize

private

Definition at line 73 of file LArFFT.h.

Referenced by AlignedSum(), DoInvFFT(), FFTSize(), InitializeFFT(), LArFFT(), PeakCorrelation(), ReinitializeFFT(), resetSizePerRun(), and ShiftData().

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

lardata/v09_16_03/source/lardata/Utilities/LArFFT.h
lardata/v09_16_03/source/lardata/Utilities/LArFFT.cc

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation