#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 ()

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 25 of file LArFFT_service.cc.

References fSize, and InitializeFFT().

   : 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) 
     fSize = art::ServiceHandle<detinfo::DetectorPropertiesService>()->provider()->ReadOutWindowSize();
 
   InitializeFFT();
 }

util::LArFFT::~LArFFT ( )

Definition at line 66 of file LArFFT_service.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 243 of file LArFFT.h.

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

Referenced by caldata::CalWireAna::analyze(), detsim::SimWire::ConvoluteResponseFunctions(), and detsim::SimWireT962::ConvoluteResponseFunctions().

 {  
   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 172 of file LArFFT.h.

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

Referenced by util::SignalShaping::Convolute(), util::SignalShaping::Deconvolute(), caldata::CalWire::produce(), caldata::CalWireT962::produce(), detsim::SimWire::produce(), and detsim::SimWireT962::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 191 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 206 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 225 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 137 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 156 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 97 of file LArFFT.h.

References fFFT, and fFreqSize.

Referenced by util::SignalShaping::AddResponseFunction(), caldata::CalWireAna::analyze(), Convolute(), detsim::SimWire::ConvoluteResponseFunctions(), detsim::SimWireT962::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 119 of file LArFFT.h.

References fFreqSize, fInverseFFT, and fSize.

Referenced by util::SignalShaping::AddResponseFunction(), util::SignalShaping::CalculateDeconvKernel(), Convolute(), Correlate(), Deconvolute(), detsim::SimWire::GenNoise(), detsim::SimWireT962::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 71 of file LArFFT.h.

References fFitBins, and ReinitializeFFT().

71 { return fFitBins; }

util::LArFFT::fFitBins

int fFitBins

Definition: LArFFT.h:80

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

inline

Definition at line 70 of file LArFFT.h.

References fOption.

70 { return fOption; }

util::LArFFT::fOption

std::string fOption

Definition: LArFFT.h:79

int util::LArFFT::FFTSize ( ) const

inline

Definition at line 69 of file LArFFT.h.

References fSize.

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

69 { return fSize; }

util::LArFFT::fSize

int fSize

Definition: LArFFT.h:77

void util::LArFFT::InitializeFFT ( )

private

Definition at line 40 of file LArFFT_service.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){ }   
   // mf::LogInfo("LArFFt") << "Requested size: " << fSize << " FFT size: " << i ;
    
   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 271 of file LArFFT.h.

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

Referenced by AlignedSum(), 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 75 of file LArFFT_service.cc.

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

Referenced by FFTFitBins().

                                                                        {
 
   //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::ShiftData	(	std::vector< TComplex > &	input,
		double	shift
	)

Definition at line 107 of file LArFFT_service.cc.

References DEFINE_ART_SERVICE, fFreqSize, and fSize.

Referenced by AlignedSum(), 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 258 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 83 of file LArFFT.h.

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

TH1D* util::LArFFT::fConvHist

private

Definition at line 82 of file LArFFT.h.

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

TFFTRealComplex* util::LArFFT::fFFT

private

object to do FFT

Definition at line 86 of file LArFFT.h.

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

int util::LArFFT::fFitBins

private

Definition at line 80 of file LArFFT.h.

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

int util::LArFFT::fFreqSize

private

Definition at line 78 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 87 of file LArFFT.h.

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

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

private

Definition at line 84 of file LArFFT.h.

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

std::string util::LArFFT::fOption

private

Definition at line 79 of file LArFFT.h.

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

TF1* util::LArFFT::fPeakFit

private

Definition at line 81 of file LArFFT.h.

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

int util::LArFFT::fSize

private

Definition at line 77 of file LArFFT.h.

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

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

lardata/v06_47_03/source/lardata/Utilities/LArFFT.h
lardata/v06_47_03/source/lardata/Utilities/LArFFT_service.cc

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation