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

value

Definition: submit_mcc.py:159

template<typename T>

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

inline

Definition at line 1053 of file SimpleFits.h.

         {
           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()`
	)

Definition at line 1812 of file SimpleFits.h.

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

Definition at line 1829 of file SimpleFits.h.

 {
   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

Definition at line 1092 of file SimpleFits.h.

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

lar::util::GaussianFit::add_with_uncertainty

end

while True: pbar.update(maxval-len(onlies[E][S])) #print iS, "/", len(onlies[E][S]) found = False for...

Definition: ValidateOpDetReco.py:548

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

Definition: SimpleFits.h:1812

decltype(auto) constexpr begin(T &&obj)

ADL-aware version of std::begin.

Definition: StdUtils.h:72

template<typename T>

template<typename Iter >

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

inline

Definition at line 1061 of file SimpleFits.h.

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

lar::util::GaussianFit::add_without_uncertainty

end

while True: pbar.update(maxval-len(onlies[E][S])) #print iS, "/", len(onlies[E][S]) found = False for...

Definition: ValidateOpDetReco.py:548

void add_without_uncertainty(Iter begin, Iter end)

Definition: SimpleFits.h:1061

decltype(auto) constexpr begin(T &&obj)

ADL-aware version of std::begin.

Definition: StdUtils.h:72

template<typename T >

template<typename Iter , typename Pred >

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

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

Definition at line 1068 of file SimpleFits.h.

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

lar::util::GaussianFit::add_without_uncertainty

end

while True: pbar.update(maxval-len(onlies[E][S])) #print iS, "/", len(onlies[E][S]) found = False for...

Definition: ValidateOpDetReco.py:548

void add_without_uncertainty(Iter begin, Iter end)

Definition: SimpleFits.h:1061

decltype(auto) constexpr begin(T &&obj)

ADL-aware version of std::begin.

Definition: StdUtils.h:72

template<typename T>

template<typename Cont >

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

inline

Definition at line 1072 of file SimpleFits.h.

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

lar::util::GaussianFit::add_without_uncertainty

end

while True: pbar.update(maxval-len(onlies[E][S])) #print iS, "/", len(onlies[E][S]) found = False for...

Definition: ValidateOpDetReco.py:548

void add_without_uncertainty(Iter begin, Iter end)

Definition: SimpleFits.h:1061

lar::util::QuadraticFit::ChiSquare

decltype(auto) constexpr begin(T &&obj)

ADL-aware version of std::begin.

Definition: StdUtils.h:72

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.

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.

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

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

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

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); }

value

Definition: submit_mcc.py:159

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.

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

template<typename T>

template<typename Pred >

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

inlinestaticprotected

Definition at line 1364 of file SimpleFits.h.

1364 { return { pred }; }

keras_to_tensorflow.pred

list pred

Definition: keras_to_tensorflow.py:125

template<typename T>

template<typename VPred , typename UPred >

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

inlinestaticprotected

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); }

value

Definition: submit_mcc.py:159

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) }; }

error

Definition: include.cc:26

abs

T abs(T value)

Definition: sparse_vector_test.cc:30

lar::util::GaussianFit::EncodeValue

value

Definition: submit_mcc.py:159

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.

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

static Data_t EncodeValue(Data_t value)

Definition: SimpleFits.h:1265

lar::util::GaussianFit::Evaluate

value

Definition: submit_mcc.py:159

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.

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

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

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()); }

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

make_THn_beam_input.data

data

Definition: make_THn_beam_input.py:80

train.x

list x

Definition: train.py:276

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.

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

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.

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

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.

 {
   // 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()

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

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.

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)

template<typename T>

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

inline

Returns the number of (valid) points added.

Definition at line 1100 of file SimpleFits.h.

1100 { return fitter.N(); }

lar::util::details::SimplePolyFitterDataBase::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.

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::SimplePolyFitterDataBase::PrintStats

Fitter_t fitter

the actual fitter and data holder

Definition: SimpleFits.h:1242

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); }

void PrintStats(Stream &out) const

Prints the collected statistics into a stream.

Definition: SimpleFits.h:436