LArSoft: lar::util::GaussianFit< T > Class Template Reference

lar::util::GaussianFit::add_with_uncertainty

std::string value(boost::any const &)

Definition: printing_helpers.cc:97

template<typename T>

bool lar::util::GaussianFit< T >::add ( MeasurementAndUncertainty_t value )

inline

Clears all the input statistics.

Definition at line 1053 of file SimpleFits.h.

References lar::util::details::FitDataCollector< T, D >::add().

         {
           return 
             add(std::get<0>(value), std::get<1>(value), std::get<2>(value));
         }

template<typename T >

template<typename VIter , typename UIter , typename VPred , typename UPred >

unsigned int lar::util::GaussianFit< T >::add_with_uncertainty	(	VIter	begin_value,
		VIter	end_value,
		UIter	begin_uncertainty,
		VPred	value_extractor,
		UPred	uncertainty_extractor = `UPred()`
	)

Clears all the input statistics.

Definition at line 1812 of file SimpleFits.h.

References lar::util::details::FitDataCollector< T, D >::add_with_uncertainty().

 {
   return add_with_uncertainty(
     begin_value, end_value, begin_uncertainty,
     Encoder(value_extractor, uncertainty_extractor)
     );
 } // GaussianFit<T>::add_with_uncertainty()

template<typename T >

template<typename Iter >

unsigned int lar::util::GaussianFit< T >::add_with_uncertainty	(	Iter	begin,
		Iter	end
	)

Clears all the input statistics.

Definition at line 1829 of file SimpleFits.h.

References lar::util::details::FitDataCollector< T, D >::add(), and lar::util::details::FitDataCollector< T, D >::N().

 {
   unsigned int old_n = N();
   std::for_each(begin, end, [this](auto p) { this->add(p); });
   return N() - old_n;
 } // GaussianFit<T>::add_with_uncertainty()

template<typename T>

template<typename Cont >

unsigned int lar::util::GaussianFit< T >::add_with_uncertainty ( Cont cont )

inline

Clears all the input statistics.

Definition at line 1092 of file SimpleFits.h.

References lar::util::details::FitDataCollector< T, D >::add_with_uncertainty(), evd::details::begin(), and evd::details::end().

1093 { return add_with_uncertainty(std::begin(cont), std::end(cont)); }

unsigned int add_with_uncertainty(VIter begin_value, VIter end_value, UIter begin_uncertainty, VPred value_extractor, UPred uncertainty_extractor=UPred())

Clears all the input statistics.

Definition: SimpleFits.h:1812

std::vector< evd::details::RawDigitInfo_t >::const_iterator begin(RawDigitCacheDataClass const &cache)

Definition: RawDataDrawer.cxx:314

std::vector< evd::details::RawDigitInfo_t >::const_iterator end(RawDigitCacheDataClass const &cache)

Definition: RawDataDrawer.cxx:317

template<typename T>

template<typename Iter >

void lar::util::GaussianFit< T >::add_without_uncertainty	(	Iter	begin,
		Iter	end
	)

inline

Clears all the input statistics.

Definition at line 1061 of file SimpleFits.h.

References lar::util::details::FitDataCollector< T, D >::add_without_uncertainty(), evd::details::begin(), and evd::details::end().

Referenced by lar::util::GaussianFit< T >::add().

1062 { add_without_uncertainty(begin, end, identity()); }

lar::util::GaussianFit::add_without_uncertainty

std::vector< evd::details::RawDigitInfo_t >::const_iterator begin(RawDigitCacheDataClass const &cache)

Definition: RawDataDrawer.cxx:314

void add_without_uncertainty(Iter begin, Iter end)

Clears all the input statistics.

Definition: SimpleFits.h:1061

std::vector< evd::details::RawDigitInfo_t >::const_iterator end(RawDigitCacheDataClass const &cache)

Definition: RawDataDrawer.cxx:317

template<typename T >

template<typename Iter , typename Pred >

void lar::util::GaussianFit< T >::add_without_uncertainty	(	Iter	begin,
		Iter	end,
		Pred	extractor
	)

Clears all the input statistics.

Definition at line 1801 of file SimpleFits.h.

 {
   return fitter.add_without_uncertainty(begin, end, Encoder(extractor));
 } // GaussianFit<>::add_without_uncertainty(Iter, Iter, Pred)

template<typename T>

template<typename Cont , typename Pred >

void lar::util::GaussianFit< T >::add_without_uncertainty	(	Cont	cont,
		Pred	extractor
	)

inline

Clears all the input statistics.

Definition at line 1068 of file SimpleFits.h.

References lar::util::details::FitDataCollector< T, D >::add_without_uncertainty(), evd::details::begin(), and evd::details::end().

1069 { add_without_uncertainty(std::begin(cont), std::end(cont), extractor); }

lar::util::GaussianFit::add_without_uncertainty

std::vector< evd::details::RawDigitInfo_t >::const_iterator begin(RawDigitCacheDataClass const &cache)

Definition: RawDataDrawer.cxx:314

void add_without_uncertainty(Iter begin, Iter end)

Clears all the input statistics.

Definition: SimpleFits.h:1061

std::vector< evd::details::RawDigitInfo_t >::const_iterator end(RawDigitCacheDataClass const &cache)

Definition: RawDataDrawer.cxx:317

template<typename T>

template<typename Cont >

void lar::util::GaussianFit< T >::add_without_uncertainty ( Cont cont )

inline

Clears all the input statistics.

Definition at line 1072 of file SimpleFits.h.

References lar::util::details::FitDataCollector< T, D >::add_with_uncertainty(), lar::util::details::FitDataCollector< T, D >::add_without_uncertainty(), evd::details::begin(), and evd::details::end().

1073 { add_without_uncertainty(std::begin(cont), std::end(cont)); }

lar::util::GaussianFit::add_without_uncertainty

std::vector< evd::details::RawDigitInfo_t >::const_iterator begin(RawDigitCacheDataClass const &cache)

Definition: RawDataDrawer.cxx:314

void add_without_uncertainty(Iter begin, Iter end)

Clears all the input statistics.

Definition: SimpleFits.h:1061

lar::util::QuadraticFit::ChiSquare

std::vector< evd::details::RawDigitInfo_t >::const_iterator end(RawDigitCacheDataClass const &cache)

Definition: RawDataDrawer.cxx:317

template<typename T>

virtual Data_t lar::util::GaussianFit< T >::ChiSquare ( ) const

inlineoverridevirtual

Returns the $\chi^{2}$ of the original fit.

Returns: the $\chi^{2}$ of the original fit (not divided by NDF())

This is not defined in the space of the Gaussian, but in the space of the internal quadratic fit. Where one is minimum, the other also is, but the actual value is different.

Implements lar::util::details::SimpleFitterInterface< T, 3 >.

Definition at line 1161 of file SimpleFits.h.

Referenced by hit::CCHitFinderAlg::FastGaussianFit().

1161 { return fitter.ChiSquare(); }

virtual Data_t ChiSquare() const override

Returns the of the fit.

Definition: SimpleFits.h:1771

lar::util::details::SimplePolyFitterDataBase::clear

Fitter_t fitter

the actual fitter and data holder

Definition: SimpleFits.h:1242

template<typename T>

void lar::util::GaussianFit< T >::clear ( )

inline

Clears all the input statistics.

Definition at line 1097 of file SimpleFits.h.

1097 { fitter.clear(); }

void clear()

Clears all the statistics.

Definition: SimpleFits.h:421

Fitter_t fitter

the actual fitter and data holder

Definition: SimpleFits.h:1242

template<typename T >

auto lar::util::GaussianFit< T >::ConvertParameters ( FitParameters_t const & qpars )

staticprotected

Converts the specified quadratic fit parameters into Gaussian.

Parameters

qpars the quadratic fit parameters

Returns: Gaussian function parameters

Definition at line 1920 of file SimpleFits.h.

References lar::util::details::FitDataCollector< T, D >::sqr().

 {
   FitParameters_t params;
   
   
   Data_t sigma2 = -0.5 / qpars[2]; // sigma^2 = -1 / (2 a2)
   params[2] = std::sqrt(sigma2); // sigma
   
   params[1] = sigma2 * qpars[1]; // mean = sigma2 a1
   
   params[0] = std::exp(qpars[0] - 0.25 * sqr(qpars[1])/qpars[2]);
   
   return params;
 } // GaussianFit<>::ConvertParameters()

template<typename T >

void lar::util::GaussianFit< T >::ConvertParametersAndErrorMatrix	(	FitParameters_t const &	qpars,
		FitMatrix_t const &	qparerrmat,
		FitParameters_t &	params,
		FitMatrix_t &	Smat
	)

staticprotected

Converts the specified quadratic fit parameters and errors.

Parameters

qpars	the quadratic fit parameters
qparerrmat	the quadratic fit parameter error matrix
params	the Gaussian fit parameters
Smat	the covariance matrix of the Gaussian fit parameters

Definition at line 1986 of file SimpleFits.h.

References lar::util::GaussianFit< T >::isValid(), and lar::util::details::FitDataCollector< T, D >::sqr().

 {
   FitParameters_t paramvariances;
   ConvertParametersAndVariances(qpars, qparerrmat, params, paramvariances);
   
   // let's call things with their names
   FitParameters_t const& a     = qpars;
   Data_t          const& A     = params[0];
   Data_t          const& mu    = params[1];
   Data_t          const& sigma = params[2];
   
   // variance on sigma
   Smat[3 * 2 + 2] = paramvariances[2];
   
   // variance on mu
   Smat[3 * 1 + 1] = paramvariances[1];
   
   // variance on A
   Smat[3 * 0 + 0] = paramvariances[0];
   
   // covariance on sigma and mu
   Smat[3 * 1 + 2] = Smat[3 * 2 + 1]
     = (qparerrmat[3 * 1 + 2] + 2 * mu * qparerrmat[3 * 2 + 2]) / sigma;
   
   // this is the sum of the derivatives of A vs. all a parameters, each one
   // multiplied by the covariance of that parameter with a2
   const Data_t dA_dak_cov_aka2 = A * (
         qparerrmat[3 * 0 + 2]
       + qparerrmat[3 * 1 + 2] * mu
       + qparerrmat[3 * 2 + 2] * sqr(mu)
     );
   // covariance on A and sigma
   Smat[3 * 0 + 2] = Smat[3 * 2 + 0]
     = dA_dak_cov_aka2 / cube(sigma);
   
   // this other is the same as dA_dak_cov_aka2, but for a1
   const Data_t dA_dak_cov_aka1 = A * (
         qparerrmat[3 * 0 + 1]
       + qparerrmat[3 * 1 + 1] * mu
       + qparerrmat[3 * 2 + 1] * sqr(mu)
     );
   
   // covariance on A and mu
   Smat[3 * 0 + 1] = Smat[3 * 1 + 0] = mu *
     (dA_dak_cov_aka1 / a[1] - dA_dak_cov_aka2 / a[2]);
   
 } // GaussianFit<>::ConvertParametersAndErrors()

template<typename T >

void lar::util::GaussianFit< T >::ConvertParametersAndErrors	(	FitParameters_t const &	qpars,
		FitMatrix_t const &	qparerrmat,
		FitParameters_t &	params,
		FitParameters_t &	paramerrors
	)

staticprotected

Converts the specified quadratic fit parameters and errors.

Parameters

qpars	the quadratic fit parameters
qparerrmat	the quadratic fit parameter error matrix
params	the Gaussian fit parameters
paramerrors	the Gaussian fit parameter errors

Definition at line 1974 of file SimpleFits.h.

 {
   ConvertParametersAndVariances(qpars, qparerrmat, params, paramerrors);
   // paramerrors actually stores the square of the error; fix it:
   for (Data_t& paramerror: paramerrors) paramerror = std::sqrt(paramerror);
 } // GaussianFit<>::ConvertParametersAndErrors()

template<typename T >

void lar::util::GaussianFit< T >::ConvertParametersAndVariances	(	FitParameters_t const &	qpars,
		FitMatrix_t const &	qparerrmat,
		FitParameters_t &	params,
		FitParameters_t &	paramvariances
	)

staticprotected

Converts the specified quadratic fit parameters and errors.

Parameters

qpars	the quadratic fit parameters
qparerrmat	the quadratic fit parameter error matrix
params	the Gaussian fit parameters
paramvariances	the Gaussian fit parameter variance

Definition at line 1938 of file SimpleFits.h.

References lar::util::details::FitDataCollector< T, D >::sqr().

 {
   params = ConvertParameters(qpars);
   
   FitParameters_t const& a     = qpars;
   Data_t          const& A     = params[0];
   Data_t          const& mu    = params[1];
   Data_t          const& sigma = params[2];
   
   // error on sigma
   paramvariances[2] = qparerrmat[3 * 2 + 2] / sqr(cube(sigma));
   
   // error on mu
   paramvariances[1] = sqr(mu * (
     +    qparerrmat[3 * 1 + 1] / sqr(a[1])
     - 2.*qparerrmat[3 * 2 + 1] / (a[1]*a[2])
     +    qparerrmat[3 * 2 + 2] / sqr(a[2])
     ));
   
   // error on A
   paramvariances[0] = sqr(A * (
     +     qparerrmat[3 * 0 + 0]
     +  2.*qparerrmat[3 * 0 + 1]  * mu
     +(    qparerrmat[3 * 1 + 1]
      + 2.*qparerrmat[3 * 0 + 2]) * sqr(mu)
     +  2.*qparerrmat[3 * 1 + 2]  * cube(mu)
     +     qparerrmat[3 * 2 + 2]  * sqr(sqr(mu))
     ));
   
 } // GaussianFit<>::ConvertParametersAndVariances()

static constexpr Data_t lar::util::details::SimpleFitterInterface< T, N >::cube ( Data_t v )

inlinestaticinherited

Returns the cube of the specified data value.

Definition at line 610 of file SimpleFits.h.

610 { return v*v*v; }

template<typename T>

static Data_t lar::util::GaussianFit< T >::DecodeValue ( Data_t value )

inlinestaticprotected

Converts a value from the quadratic fit into a proper value.

Definition at line 1268 of file SimpleFits.h.

1268 { return std::exp(value); }

std::string value(boost::any const &)

Definition: printing_helpers.cc:97

template<typename T>

static Value_t lar::util::GaussianFit< T >::DecodeValue ( Value_t const & value )

inlinestaticprotected

Converts a value from the quadratic fit into a proper value.

Definition at line 1282 of file SimpleFits.h.

References lar::util::GaussianFit< T >::Value_t::error(), and lar::util::GaussianFit< T >::Value_t::value().

         {
           const Data_t v = std::exp(value.value());
           return { v, v * value.error() };
         } // DecodeValue()

virtual Data_t lar::util::details::SimpleFitterInterface< T, N >::Determinant ( FitMatrix_t const & mat ) const

inlineprotectedvirtualinherited

Computes the determinant of a matrix.

Definition at line 615 of file SimpleFits.h.

616 { return MatrixOps::Determinant(mat); }

Float_t mat

Definition: plot.C:40

template<typename T>

template<typename Pred >

static EncodeExtractor<Pred> lar::util::GaussianFit< T >::Encoder ( Pred & pred )

inlinestaticprotected

Converts a value into a proper input for the quadratic fit; does not accept 0 or negative values!

Definition at line 1364 of file SimpleFits.h.

1364 { return { pred }; }

template<typename T>

template<typename VPred , typename UPred >

static EncodeExtractor<VPred, UPred> lar::util::GaussianFit< T >::Encoder	(	VPred &	vpred,
		UPred &	upred
	)

inlinestaticprotected

Converts a value into a proper input for the quadratic fit; does not accept 0 or negative values!

Definition at line 1367 of file SimpleFits.h.

1368 { return { vpred, upred }; }

template<typename T>

static Data_t lar::util::GaussianFit< T >::EncodeValue ( Data_t value )

inlinestaticprotected

Converts a value into a proper input for the quadratic fit; does not accept 0 or negative values!

Definition at line 1265 of file SimpleFits.h.

1265 { return std::log(value); }

std::string value(boost::any const &)

Definition: printing_helpers.cc:97

template<typename T>

static Value_t lar::util::GaussianFit< T >::EncodeValue	(	Data_t	value,
		Data_t	error
	)

inlinestaticprotected

Converts a value and error into a proper input for the quadratic fit.

Definition at line 1272 of file SimpleFits.h.

1273 { return { std::log(value), error / std::abs(value) }; }

mf::errors::error

error

Definition: exception.h:9

std::string value(boost::any const &)

Definition: printing_helpers.cc:97

template<typename T>

static Value_t lar::util::GaussianFit< T >::EncodeValue ( Value_t const & value )

inlinestaticprotected

Converts a value and error into a proper input for the quadratic fit.

Definition at line 1277 of file SimpleFits.h.

References lar::util::GaussianFit< T >::Value_t::error(), and lar::util::GaussianFit< T >::Value_t::value().

1278 { return EncodeValue(value.value(), value.error()); }

lar::util::GaussianFit::EncodeValue

std::string value(boost::any const &)

Definition: printing_helpers.cc:97

static Data_t EncodeValue(Data_t value)

Definition: SimpleFits.h:1265

template<typename T>

static Measurement_t lar::util::GaussianFit< T >::EncodeValue ( Measurement_t const & meas )

inlinestaticprotected

Converts a value and error into a proper input for the quadratic fit.

Definition at line 1289 of file SimpleFits.h.

         {
           return
             Measurement_t(std::get<0>(meas), EncodeValue(std::get<1>(meas)));
         }

template<typename T>

static MeasurementAndUncertainty_t lar::util::GaussianFit< T >::EncodeValue ( MeasurementAndUncertainty_t const & meas )

inlinestaticprotected

Converts a value and error into a proper input for the quadratic fit.

Definition at line 1297 of file SimpleFits.h.

References lar::util::GaussianFit< T >::Value_t::error(), and lar::util::GaussianFit< T >::Value_t::value().

         {
           Value_t value = EncodeValue(Value_t(meas));
           return { std::get<0>(meas), value.value(), value.error() };
         } // EncodeValue(MeasurementAndUncertainty_t)

template<typename T>

static MeasurementAndUncertainty_t lar::util::GaussianFit< T >::EncodeValue	(	Measurement_t const &	meas,
		Data_t	error
	)

inlinestaticprotected

Converts a value and error into a proper input for the quadratic fit.

Definition at line 1305 of file SimpleFits.h.

References lar::util::GaussianFit< T >::Value_t::error(), and lar::util::GaussianFit< T >::Value_t::value().

         {
           Value_t value = EncodeValue(Value_t(std::get<1>(meas), error));
           return { std::get<0>(meas), value.value(), value.error() };
         } // EncodeValue(Measurement_t, Data_t)

virtual Data_t lar::util::details::SimpleFitterInterface< T, N >::Evaluate ( Data_t x ) const

pure virtualinherited

Evaluates the fitted function at the specified point.

Parameters

x	the point where to evaluate the fit function

Returns: the value of the fit function

No check is performed whether the fit is valid.

template<typename T>

virtual Data_t lar::util::GaussianFit< T >::Evaluate ( Data_t x ) const

inlineoverridevirtual

Evaluates the fitted function at the specified point.

Parameters

x	the point where to evaluate the fit function

Returns: the value of the fit function

No check is performed whether the fit is valid.

Definition at line 1225 of file SimpleFits.h.

1226 { return Evaluate(x, FitParameters().data()); }

x

Float_t x

Definition: compare.C:6

lar::util::GaussianFit::Evaluate

virtual Data_t Evaluate(Data_t x) const override

Evaluates the fitted function at the specified point.

Definition: SimpleFits.h:1225

lar::util::GaussianFit::FitParameters

virtual FitParameters_t FitParameters() const override

Computes and returns all the parameters of the fit result.

Definition: SimpleFits.h:1841

template<typename T >

auto lar::util::GaussianFit< T >::Evaluate	(	Data_t	x,
		Data_t const *	params
	)

static

Evaluates a Gaussian with given parameters at one point.

Parameters

x	the point where to evaluate the fit function
params	Gaussian parameters: amplitude, mean, sigma

Returns: the Gaussian function evaluated at x

Definition at line 1911 of file SimpleFits.h.

References lar::util::details::FitDataCollector< T, D >::sqr(), and z.

 {
   Data_t z = (x - params[1]) / params[2];
   return params[0] * std::exp(-0.5*sqr(z));
 } // GaussianFit<>::Evaluate()

virtual bool lar::util::details::SimpleFitterInterface< T, N >::FillResults	(	FitParameters_t &	params,
		FitMatrix_t &	Xmat,
		Data_t &	det,
		FitMatrix_t &	Smat
	)		const

pure virtualinherited

Fills the specified parameters.

Parameters

params	the fitted values of the parameters
Xmat	the matrix of the x^n/s^2 sums
Smat	the covariance matrix
det	the determinant of Xmat

Returns: true if the fit is valid (i.e. if a unique solution exists)

virtual bool lar::util::details::SimpleFitterInterface< T, N >::FillResults	(	FitParameters_t &	params,
		FitParameters_t &	paramerrors,
		FitMatrix_t &	Xmat,
		Data_t &	det,
		FitMatrix_t &	Smat
	)		const

pure virtualinherited

Fills the specified parameters.

Parameters

params	the fitted values of the parameters
paramerrors	the uncertainty on the fitted parameters
Xmat	the matrix of the x^n/s^2 sums
Smat	the covariance matrix
det	the determinant of Xmat

Returns: true if the fit is valid (i.e. if a unique solution exists)

virtual bool lar::util::details::SimpleFitterInterface< T, N >::FillResults	(	FitParameters_t &	params,
		FitParameters_t &	paramerrors
	)		const

pure virtualinherited

Fills the specified parameters.

Parameters

params	the fitted values of the parameters
paramerrors	the uncertainty on the fitted parameters

Returns: true if the fit is valid (i.e. if a unique solution exists)

template<typename T >

bool lar::util::GaussianFit< T >::FillResults	(	FitParameters_t &	params,
		FitMatrix_t &	Xmat,
		Data_t &	det,
		FitMatrix_t &	Smat
	)		const

overridevirtual

Fills the specified parameters.

Parameters

params	the fitted values of the parameters
Xmat	the matrix of the x^n/s^2 sums
Smat	the covariance matrix
det	the determinant of Xmat

Returns: true if the fit is valid (i.e. if a unique solution exists)

Unsupported.

Definition at line 1888 of file SimpleFits.h.

Referenced by hit::CCHitFinderAlg::FastGaussianFit(), and lar::util::GaussianFit< T >::FitParameterCovariance().

         {
   FitParameters_t qpars;
   FitMatrix_t qparerrmat;
   if (!fitter.FillResults(qpars, Xmat, det, qparerrmat)) return false;
   ConvertParametersAndErrorMatrix(qpars, qparerrmat, params, Smat);
   return isValid(params, qpars);
 } // GaussianFit::FillResults()

template<typename T >

bool lar::util::GaussianFit< T >::FillResults	(	FitParameters_t &	params,
		FitParameters_t &	paramerrors,
		FitMatrix_t &	Xmat,
		Data_t &	det,
		FitMatrix_t &	Smat
	)		const

overridevirtual

Fills the specified parameters.

Parameters

params	the fitted values of the parameters
paramerrors	the uncertainty on the fitted parameters
Xmat	the matrix of the x^n/s^2 sums
Smat	the covariance matrix
det	the determinant of Xmat

Returns: true if the fit is valid (i.e. if a unique solution exists)

Unsupported.

Definition at line 1900 of file SimpleFits.h.

         {
   if (!FillResults(params, Xmat, det, Smat)) return false;
   paramerrors = fitter.ExtractParameterErrors(Smat);
   return true;
 } // GaussianFit::FillResults()

template<typename T >

bool lar::util::GaussianFit< T >::FillResults	(	FitParameters_t &	params,
		FitParameters_t &	paramerrors
	)		const

overridevirtual

Fills the specified parameters.

Parameters

params	the fitted values of the parameters
paramerrors	the uncertainty on the fitted parameters

Returns: true if the fit is valid (i.e. if a unique solution exists)

Only the version returning the parameters and errors is supported.

Definition at line 1875 of file SimpleFits.h.

 {
   FitParameters_t qpars;
   FitMatrix_t qparerrmat;
   FitMatrix_t Xmat; // not used
   Data_t det; // not used
   if (!fitter.FillResults(qpars, Xmat, det, qparerrmat)) return false;
   ConvertParametersAndErrors(qpars, qparerrmat, params, paramerrors);
   return isValid(params, qpars);
 } // GaussianFit<>::FillResults()

virtual Data_t lar::util::details::SimpleFitterInterface< T, N >::FitParameter ( unsigned int n ) const

inlinevirtualinherited

Returns the parameter n of the fit result.

Parameters

n	degree of the parameter; must be no larger than Degree

Returns: the parameter of the fit, in y/x^n units

Exceptions

std::runtime_error if there is no unique solution

Definition at line 524 of file SimpleFits.h.

525 { return FitParameters()[n]; }

lar::util::details::SimpleFitterInterface< T, 3 >::FitParameters

virtual FitParameters_t FitParameters() const =0

Computes and returns all the parameters of the fit result.

n

Char_t n[5]

Definition: comparison_ascii.C:55

template<typename T >

auto lar::util::GaussianFit< T >::FitParameterCovariance ( ) const

overridevirtual

Computes and returns all the covariance matrix of the fit result.

Returns: the the covariance matrix of the fit

Exceptions

std::runtime_error if there is no unique solution

Not supported. It's fairly too complicate to fill the whole matrix. Doable, on request.

Implements lar::util::details::SimpleFitterInterface< T, 3 >.

Definition at line 1858 of file SimpleFits.h.

References lar::util::GaussianFit< T >::FillResults().

 {
   // we need to go through the whole chain to get the error matrix
   FitParameters_t params;
   FitMatrix_t Xmat;
   Data_t det;
   FitMatrix_t Smat;
   if (!FillResults(params, Xmat, det, Smat)) {
     throw std::runtime_error
       ("GaussianFit::FitParameterCovariance() yielded invalid results");
   }
   return Smat;
 } // SimplePolyFitterBase<>::FitParameterCovariance()

virtual Data_t lar::util::details::SimpleFitterInterface< T, N >::FitParameterError ( unsigned int n ) const

inlinevirtualinherited

Returns the error on parameter n of the fit result.

Parameters

n	degree of the parameter; must be no larger than Degree

Returns: the error on the parameter of the fit, in y/x^n units

Exceptions

std::runtime_error if there is no unique solution

Definition at line 533 of file SimpleFits.h.

534 { return std::sqrt(FitParameterCovariance()[n * (NParams + 1)]); }

lar::util::details::SimpleFitterInterface< T, 3 >::FitParameterCovariance

virtual FitMatrix_t FitParameterCovariance() const =0

Computes and returns all the covariance matrix of the fit result.

lar::util::details::SimpleFitterInterface< T, 3 >::NParams

static constexpr unsigned int NParams

Number of parameters in the fit.

Definition: SimpleFits.h:462

n

Char_t n[5]

Definition: comparison_ascii.C:55

template<typename T >

auto lar::util::GaussianFit< T >::FitParameterErrors ( ) const

overridevirtual

Computes and returns all the parameter errors of the fit result.

Returns: the full set of parameter errors of the fit

Exceptions

std::runtime_error if there is no unique solution

Implements lar::util::details::SimpleFitterInterface< T, 3 >.

Definition at line 1847 of file SimpleFits.h.

                                                                         {
   FitParameters_t qpars, qparerrors;
   if (!FillResults(qpars, qparerrors)) {
     throw std::runtime_error
       ("GaussianFit::FitParameterErrors() yielded invalid results");
   }
   return qparerrors;
 } // GaussianFit<>::FitParameterErrors()

template<typename T >

auto lar::util::GaussianFit< T >::FitParameters ( ) const

overridevirtual

Computes and returns all the parameters of the fit result.

Returns: the full set of parameters of the fit

Exceptions

std::runtime_error if there is no unique solution

Implements lar::util::details::SimpleFitterInterface< T, 3 >.

Definition at line 1841 of file SimpleFits.h.

                                                                    {
   return ConvertParameters(fitter.FitParameters());
 } // GaussianFit<>::FitParameters()

template<typename T>

virtual Fitter_t const& lar::util::GaussianFit< T >::Fitter ( ) const

inlinevirtual

Returns the internal fitter (mostly for debugging)

Definition at line 1230 of file SimpleFits.h.

1230 { return fitter; }

Fitter_t fitter

the actual fitter and data holder

Definition: SimpleFits.h:1242

virtual FitMatrix_t lar::util::details::SimpleFitterInterface< T, N >::InvertMatrix	(	FitMatrix_t const &	mat,
		Data_t	det
	)		const

inlineprotectedvirtualinherited

Computes the inverse of a matrix (using provided determinant)

Definition at line 620 of file SimpleFits.h.

621 { return MatrixOps::InvertSymmetricMatrix(mat, det); }

Float_t mat

Definition: plot.C:40

virtual FitMatrix_t lar::util::details::SimpleFitterInterface< T, N >::InvertMatrix ( FitMatrix_t const & mat ) const

inlineprotectedvirtualinherited

Computes the inverse of a matrix.

Definition at line 624 of file SimpleFits.h.

625 { return MatrixOps::InvertSymmetricMatrix(mat); }

Float_t mat

Definition: plot.C:40

template<typename T>

virtual bool lar::util::GaussianFit< T >::isValid ( ) const

inlineoverridevirtual

Returns if the fit has valid results.

Returns: if the fit has valid results

The fit has no valid results if:

insufficient data has been add()ed (no more than the fit Degree)
if input points are vertically aligned

Note that checking point 2 is expensive in terms of time.

Implements lar::util::details::SimpleFitterInterface< T, 3 >.

Definition at line 1122 of file SimpleFits.h.

Referenced by lar::util::GaussianFit< T >::ConvertParametersAndErrorMatrix().

1122 { return fitter.isValid(); }

lar::util::details::SimplePolyFitterBase::isValid

Fitter_t fitter

the actual fitter and data holder

Definition: SimpleFits.h:1242

virtual bool isValid() const override

Returns if the fit has valid results.

Definition: SimpleFits.h:1540

template<typename T >

bool lar::util::GaussianFit< T >::isValid	(	FitParameters_t const &	params,
		FitParameters_t const &	qpars
	)

staticprotected

Returns whether the specified parameters represent a valid fit.

Parameters

params	Gaussian parameters
qpars	quadratic fit parameters

Returns: whether specified parameters represent a valid Gaussian fit

Definition at line 2040 of file SimpleFits.h.

 {
   return (qpars[2] < Data_t(0)) && (params[0] >= Data_t(0));
 } // GaussianFit<>::isValid(FitParameters_t)

virtual FitParameters_t lar::util::details::SimpleFitterInterface< T, N >::MatrixProduct	(	FitMatrix_t const &	mat,
		FitParameters_t const &	vec
	)		const

inlineprotectedvirtualinherited

Computes the product of a FitMatrix_t and a FitParameters_t.

Definition at line 629 of file SimpleFits.h.

630 { return MatrixOps::MatrixVectorProduct(mat, vec); }

lar::util::details::SimplePolyFitterDataBase::N

Float_t mat

Definition: plot.C:40

template<typename T>

int lar::util::GaussianFit< T >::N ( ) const

inline

Returns the number of (valid) points added.

Definition at line 1100 of file SimpleFits.h.

1100 { return fitter.N(); }

int N() const

Definition: SimpleFits.h:427

lar::util::details::SimplePolyFitterBase::NDF

Fitter_t fitter

the actual fitter and data holder

Definition: SimpleFits.h:1242

template<typename T>

virtual int lar::util::GaussianFit< T >::NDF ( ) const

inlineoverridevirtual

Returns the degrees of freedom in the determination of the fit.

Returns: the degrees of freedom in the determination of the fit

The return value may be 0 or negative if insufficient points have been added.

Implements lar::util::details::SimpleFitterInterface< T, 3 >.

Definition at line 1170 of file SimpleFits.h.

Referenced by hit::CCHitFinderAlg::FastGaussianFit().

1170 { return fitter.NDF(); }

virtual int NDF() const override

Returns the degrees of freedom in the determination of the fit.

Definition: SimpleFits.h:731

lar::util::details::SimpleFitterInterface< T, 3 >::Evaluate

Fitter_t fitter

the actual fitter and data holder

Definition: SimpleFits.h:1242

Data_t lar::util::details::SimpleFitterInterface< T, N >::operator() ( Data_t x ) const

inlineinherited

Evaluates the fitted function; alias of Evaluate()

Definition at line 603 of file SimpleFits.h.

603 { return Evaluate(x); }

x

Float_t x

Definition: compare.C:6

virtual Data_t Evaluate(Data_t x) const =0

Evaluates the fitted function at the specified point.

template<typename T>

template<typename Stream >

void lar::util::GaussianFit< T >::PrintStats ( Stream & out ) const

inline

Prints the collected statistics into a stream.

Definition at line 1105 of file SimpleFits.h.

1105 { fitter.PrintStats(out); }

lar::util::details::SimplePolyFitterDataBase::PrintStats

void PrintStats(Stream &out) const

Prints the collected statistics into a stream.

Definition: SimpleFits.h:436