hit::RFFHitFitter Class Reference

#include <RFFHitFitter.h>

Public Member Functions
	RFFHitFitter (float, unsigned int, float, float step=0.1, float max=5.0)
	RFFHitFitter (float step=0.1, float max=5.0)
void	SetFitterParams (float, unsigned int, float)
void	RunFitter (const std::vector< float > &signal)
const std::vector< float > &	MeanVector ()
const std::vector< float > &	SigmaVector ()
const std::vector< float > &	MeanErrorVector ()
const std::vector< float > &	SigmaErrorVector ()
const std::vector< float > &	AmplitudeVector ()
const std::vector< float > &	AmplitudeErrorVector ()
unsigned int	NHits ()
void	ClearResults ()
void	PrintResults ()

Private Types
typedef std::pair< float, float >	MeanSigmaPair

Private Member Functions
void	CalculateAllMeansAndSigmas (const std::vector< float > &signal)
void	CalculateMergedMeansAndSigmas (std::size_t signal_size)
void	CalculateAmplitudes (const std::vector< float > &signal)
void	CreateMergeVector ()
bool	HitsBelowThreshold ()

Private Attributes
float	fMeanMatchThreshold
unsigned int	fMinMergeMultiplicity
float	fFinalAmpThreshold
util::GaussianEliminationAlg	fGEAlg
std::vector< float >	fMeanVector
std::vector< float >	fSigmaVector
std::vector< float >	fMeanErrorVector
std::vector< float >	fSigmaErrorVector
std::vector< float >	fAmpVector
std::vector< float >	fAmpErrorVector
std::multiset< MeanSigmaPair, SignalSetComp >	fSignalSet
std::vector< std::vector < std::multiset< MeanSigmaPair > ::iterator > >	fMergeVector

Detailed Description

Definition at line 31 of file RFFHitFitter.h.

Member Typedef Documentation

typedef std::pair<float,float> hit::RFFHitFitter::MeanSigmaPair

private

Definition at line 33 of file RFFHitFitter.h.

Constructor & Destructor Documentation

hit::RFFHitFitter::RFFHitFitter	(	float	max_mean,
		unsigned int	min_multi,
		float	threshold,
		float	step = 0.1,
		float	max = 5.0
	)

Definition at line 24 of file RFFHitFitter.cxx.

                                                 :
                                fGEAlg(step,max)
{
    SetFitterParams(max_mean,min_multi,threshold);
}

hit::RFFHitFitter::RFFHitFitter	(	float	step = 0.1,
		float	max = 5.0
	)

Title: RFFHitFitter Class Author: Wes Ketchum (wketc.nosp@m.hum@.nosp@m.lanl..nosp@m.gov)

Description: Class that does the base RFF algorithm. RFF works by simplifiying a Gaussian fit by dividing a pulse by its derivative. for a Gaussian, the result is a line, with the slope and intercept related to the sigma and mean of the Gaussian.

Input: Signal (vector of floats) Output: Guassian means and sigmas

Definition at line 20 of file RFFHitFitter.cxx.

                                                  :
  fGEAlg(step,max)
{}

Member Function Documentation

const std::vector<float>& hit::RFFHitFitter::AmplitudeErrorVector ( )

inline

Definition at line 48 of file RFFHitFitter.h.

{ return fAmpErrorVector; }

const std::vector<float>& hit::RFFHitFitter::AmplitudeVector ( )

inline

Definition at line 47 of file RFFHitFitter.h.

{ return fAmpVector; }

void hit::RFFHitFitter::CalculateAllMeansAndSigmas ( const std::vector< float > &  signal )

private

Definition at line 57 of file RFFHitFitter.cxx.

{
    if(signal.size()<=2) return;

    float prev_dev=0,this_dev=0;;
    float slope=0; float sigma=0;
    float intercept=0; float mean=0;

    for(size_t i_tick=1; i_tick < signal.size()-1; i_tick++)
    {
        this_dev = 0.5*(signal[i_tick+1]-signal[i_tick-1])/signal[i_tick];
        slope = this_dev - prev_dev;

        prev_dev = this_dev;

        if(slope>=0) continue;

        sigma = std::sqrt(-1/slope);
        intercept = 0.5*(signal[i_tick+1]-signal[i_tick-1])/signal[i_tick] - slope*i_tick;
        mean = -1*intercept/slope;

        fSignalSet.insert(std::make_pair(mean,sigma));
    }
}

void hit::RFFHitFitter::CalculateAmplitudes ( const std::vector< float > &  signal )

private

Definition at line 145 of file RFFHitFitter.cxx.

{
    std::vector<float> heightVector(fMeanVector.size());
    size_t bin=0;

    for(size_t i=0; i<fMeanVector.size(); i++)
    {
        if     (fMeanVector[i]<0)                 bin=0;
        else if(fMeanVector[i]+1 > signal.size()) bin=signal.size()-2;
        else                                      bin = std::floor(fMeanVector[i]);

        if(bin >= signal.size()-1)
            throw cet::exception("RFFHitFitter") << "Error in CalculatAmplitudes! bin is out of range!\n"
                                           << "\tFor element " << i << " bin is " << bin << "(" << fMeanVector[i] << ")"
                                           << " but size is " << signal.size() << ".\n";

        heightVector[i] = signal[bin] - (fMeanVector[i]-(float)bin)*(signal[bin]-signal[bin+1]);
    }

    fAmpVector = fGEAlg.SolveEquations(fMeanVector,fSigmaVector,heightVector);

    while(HitsBelowThreshold())
    {
        for(size_t i=0; i<fAmpVector.size(); i++)
        {
            if(fAmpVector[i] < fFinalAmpThreshold)
            {
                fMeanVector.erase(fMeanVector.begin()+i);
                fMeanErrorVector.erase(fMeanErrorVector.begin()+i);
                fSigmaVector.erase(fSigmaVector.begin()+i);
                fSigmaErrorVector.erase(fSigmaErrorVector.begin()+i);
                fAmpVector.erase(fAmpVector.begin()+i);
                heightVector.erase(heightVector.begin()+i);
            }
        }
        fAmpVector = fGEAlg.SolveEquations(fMeanVector,fSigmaVector,heightVector);
    }

    fAmpErrorVector.resize(fAmpVector.size(),0.0);
}

void hit::RFFHitFitter::CalculateMergedMeansAndSigmas ( std::size_t  signal_size )

private

Definition at line 97 of file RFFHitFitter.cxx.

{
    fMeanVector.reserve(fMergeVector.size());
    fSigmaVector.reserve(fMergeVector.size());
    fMeanErrorVector.reserve(fMergeVector.size());
    fSigmaErrorVector.reserve(fMergeVector.size());

    for(size_t i_col=0; i_col<fMergeVector.size(); i_col++)
    {
        if(fMergeVector[i_col].size()<fMinMergeMultiplicity) continue;

        fMeanVector.push_back(0.0);
        fSigmaVector.push_back(0.0);

        for(auto const& sigpair : fMergeVector[i_col])
        {
            fMeanVector.back() += sigpair->first;
            fSigmaVector.back() += sigpair->second;
        }

        fMeanVector.back() /= fMergeVector[i_col].size();
        fSigmaVector.back() /= fMergeVector[i_col].size();

        if(fMeanVector.back() < 0 || fMeanVector.back()>signal_size-1)
        {
            fMeanVector.pop_back();
            fSigmaVector.pop_back();
            continue;
        }

        fMeanErrorVector.push_back(0.0);
        fSigmaErrorVector.push_back(0.0);

        for(auto const& sigpair : fMergeVector[i_col])
        {
            fMeanErrorVector.back() +=
                (sigpair->first-fMeanVector.back())*(sigpair->first-fMeanVector.back());
            fSigmaErrorVector.back() +=
                (sigpair->second-fSigmaVector.back())*(sigpair->second-fSigmaVector.back());
        }

        fMeanErrorVector.back() = std::sqrt(fMeanErrorVector.back()) / fMergeVector[i_col].size();
        fSigmaErrorVector.back() = std::sqrt(fSigmaErrorVector.back()) / fMergeVector[i_col].size();

    }

}

void hit::RFFHitFitter::ClearResults

(

)

Definition at line 193 of file RFFHitFitter.cxx.

{
    fMeanVector.clear();
    fSigmaVector.clear();
    fMeanErrorVector.clear();
    fSigmaErrorVector.clear();
    fAmpVector.clear();
    fAmpErrorVector.clear();
    fSignalSet.clear();
    fMergeVector.clear();
}

void hit::RFFHitFitter::CreateMergeVector ( )

private

Definition at line 82 of file RFFHitFitter.cxx.

{
    fMergeVector.clear(); fMergeVector.reserve( fSignalSet.size() );

    float prev_mean=-9e6;
    for(std::multiset<MeanSigmaPair>::iterator it=fSignalSet.begin(); it!=fSignalSet.end(); it++)
    {
        if( std::abs(it->first - prev_mean) > fMeanMatchThreshold || fMergeVector.size()==0 )
            fMergeVector.push_back( std::vector< std::multiset<MeanSigmaPair>::iterator >(1,it) );
        else
            fMergeVector.back().push_back(it);
        prev_mean = it->first;
    }
}

bool hit::RFFHitFitter::HitsBelowThreshold ( )

private

Definition at line 186 of file RFFHitFitter.cxx.

{
    for(auto const& amp : fAmpVector)
        if(amp < fFinalAmpThreshold) return true;
    return false;
}

const std::vector<float>& hit::RFFHitFitter::MeanErrorVector ( )

inline

Definition at line 45 of file RFFHitFitter.h.

{ return fMeanErrorVector; }

const std::vector<float>& hit::RFFHitFitter::MeanVector ( )

inline

Definition at line 43 of file RFFHitFitter.h.

{ return fMeanVector; }

unsigned int hit::RFFHitFitter::NHits ( )

inline

Definition at line 49 of file RFFHitFitter.h.

{ return fMeanVector.size(); }

void hit::RFFHitFitter::PrintResults

(

)

Definition at line 205 of file RFFHitFitter.cxx.

{
    std::cout << "InitialSignalSet" << std::endl;

    for(auto const& sigpair : fSignalSet)
        std::cout << "\t" << sigpair.first << " / " << sigpair.second << std::endl;

    std::cout << "\nNHits = " << NHits() << std::endl;
    std::cout << "\tMean / Sigma / Amp" << std::endl;
    for(size_t i=0; i<NHits(); i++)
        std::cout << "\t"
            << fMeanVector[i] <<  " +- " << fMeanErrorVector[i] << " / "
            << fSigmaVector[i] << " +- " << fSigmaErrorVector[i] << " / "
            << fAmpVector[i] << " +- " << fAmpErrorVector[i]
            << std::endl;
}

void hit::RFFHitFitter::RunFitter

(

const std::vector< float > &

signal

)

Definition at line 48 of file RFFHitFitter.cxx.

{
    ClearResults();
    CalculateAllMeansAndSigmas(signal);
    CreateMergeVector();
    CalculateMergedMeansAndSigmas(signal.size());
    CalculateAmplitudes(signal);
}

void hit::RFFHitFitter::SetFitterParams	(	float	max_mean,
		unsigned int	min_multi,
		float	threshold
	)

Definition at line 34 of file RFFHitFitter.cxx.

{
    fMeanMatchThreshold = max_mean;
    fMinMergeMultiplicity = min_multi;

    if(fMinMergeMultiplicity==0) fMinMergeMultiplicity=1;

    fFinalAmpThreshold = threshold;

    ClearResults();
}

const std::vector<float>& hit::RFFHitFitter::SigmaErrorVector ( )

inline

Definition at line 46 of file RFFHitFitter.h.

{ return fSigmaErrorVector; }

const std::vector<float>& hit::RFFHitFitter::SigmaVector ( )

inline

Definition at line 44 of file RFFHitFitter.h.

{ return fSigmaVector; }

Member Data Documentation

std::vector<float> hit::RFFHitFitter::fAmpErrorVector

private

Definition at line 70 of file RFFHitFitter.h.

std::vector<float> hit::RFFHitFitter::fAmpVector

private

Definition at line 69 of file RFFHitFitter.h.

float hit::RFFHitFitter::fFinalAmpThreshold

private

Definition at line 58 of file RFFHitFitter.h.

util::GaussianEliminationAlg hit::RFFHitFitter::fGEAlg

private

Definition at line 63 of file RFFHitFitter.h.

std::vector<float> hit::RFFHitFitter::fMeanErrorVector

private

Definition at line 67 of file RFFHitFitter.h.

float hit::RFFHitFitter::fMeanMatchThreshold

private

Definition at line 56 of file RFFHitFitter.h.

std::vector<float> hit::RFFHitFitter::fMeanVector

private

Definition at line 65 of file RFFHitFitter.h.

std::vector< std::vector< std::multiset<MeanSigmaPair>::iterator > > hit::RFFHitFitter::fMergeVector

private

Definition at line 74 of file RFFHitFitter.h.

unsigned int hit::RFFHitFitter::fMinMergeMultiplicity

private

Definition at line 57 of file RFFHitFitter.h.

std::vector<float> hit::RFFHitFitter::fSigmaErrorVector

private

Definition at line 68 of file RFFHitFitter.h.

std::vector<float> hit::RFFHitFitter::fSigmaVector

private

Definition at line 66 of file RFFHitFitter.h.

std::multiset< MeanSigmaPair, SignalSetComp > hit::RFFHitFitter::fSignalSet

private

Definition at line 72 of file RFFHitFitter.h.

---

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

• RFFHitFitter.h
• RFFHitFitter.cxx