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

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

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

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

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

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

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

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

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

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

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

 {
   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.

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.

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.

69 { return fSize; }

util::LArFFT::fSize

int fSize

Definition: LArFFT.h:77

void util::LArFFT::InitializeFFT ( )

private

Definition at line 52 of file LArFFT_service.cc.

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

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

 {
   //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 42 of file LArFFT_service.cc.

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

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

 {
   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.

TH1D* util::LArFFT::fConvHist

private

Definition at line 82 of file LArFFT.h.

TFFTRealComplex* util::LArFFT::fFFT

private

object to do FFT

Definition at line 86 of file LArFFT.h.

int util::LArFFT::fFitBins

private

Definition at line 80 of file LArFFT.h.

int util::LArFFT::fFreqSize

private

Definition at line 78 of file LArFFT.h.

TFFTComplexReal* util::LArFFT::fInverseFFT

private

object to do Inverse FF

Definition at line 87 of file LArFFT.h.

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

private

Definition at line 84 of file LArFFT.h.

std::string util::LArFFT::fOption

private

Definition at line 79 of file LArFFT.h.

TF1* util::LArFFT::fPeakFit

private

Definition at line 81 of file LArFFT.h.

int util::LArFFT::fSize

private

Definition at line 77 of file LArFFT.h.

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

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation