util::LArFFT Class Reference

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

  : 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 78 of file LArFFT.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.

{ return fFitBins; }

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

inline

Definition at line 70 of file LArFFT.h.

{ return fOption; }

int util::LArFFT::FFTSize ( ) const

inline

Definition at line 69 of file LArFFT.h.

{ return fSize; }

void util::LArFFT::InitializeFFT ( )

private

Definition at line 50 of file LArFFT.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 88 of file LArFFT.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 40 of file LArFFT.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 120 of file LArFFT.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:

• LArFFT.h
• LArFFT.cc