Regressor function object for JPoint4D fit using JGandalf minimiser. More...

#include <JShowerBrightPointRegressor.hh>

Inheritance diagram for JFIT::JRegressor< JPoint4D, JGandalf >:

Public Types
typedef JTOOLS::JSplineFunction1S_t	JFunction1D_t

typedef JTOOLS::JMAPLIST < JTOOLS::JPolint2FunctionalMap, JTOOLS::JPolint1FunctionalGridMap > ::maplist	JPDFMapList_t

typedef JPHYSICS::JPDFTable < JFunction1D_t, JPDFMapList_t >	JPDF_t

typedef JGandalf< JPoint4D >	minimiser_type

typedef JRegressor< JPoint4D, JGandalf >	regressor_type

typedef minimiser_type::result_type	result_type

typedef JPoint4D::parameter_type	parameter_type
	Data type of fit parameter. More...

Public Member Functions
	JRegressor (const std::string &fileDescriptor, const double TTS, const int numberOfPoints=25, const double epsilon=1.0e-10)
	Parameterized constructor. More...

template<class JHit_t >
result_type	operator() (const JPoint4D &vx, const JHit_t &hit) const
	Fit function. More...

JPDF_t::result_type	getH0 (const double R_Hz, const double t1) const
	Get background hypothesis value for time differentiated PDF. More...

JPDF_t::result_type	getH1 (const double D, const double ct, const double t, const double E) const
	Get signal hypothesis value for bright point emission PDF. More...

double	getRmax () const
	Get maximal road width of PDF. More...

result_type	operator() (const JPoint4D &value, T __begin, T __end)
	Global fit. More...

result_type	operator() (const JFunction_t &fit, T __begin, T __end, Args...args)
	Multi-dimensional fit of multiple data sets. More...

Public Attributes
JPDF_t	pdf [NUMBER_OF_PDFS]
	PDF. More...

double	E_GeV
	Energy of the shower [GeV]. More...

std::vector< parameter_type >	parameters
	fit parameters More...

int	numberOfIterations
	number of iterations More...

double	lambda
	control parameter More...

JPoint4D	value
	value More...

JPoint4D	error
	error More...

JMATH::JMatrixNS	V
	Hesse matrix. More...

result_type	result

Static Public Attributes
static JTimeRange	T_ns
	Time window with respect to Cherenkov hypothesis [ns]. More...

static double	Vmax_npe = std::numeric_limits<double>::max()
	Maximal integral of PDF [npe]. More...

static const int	NUMBER_OF_PDFS = 2

static const JPDFType_t	pdf_t [NUMBER_OF_PDFS]
	PDF types. More...

static int	MAXIMUM_ITERATIONS
	maximal number of iterations More...

static double	EPSILON
	maximal distance to minimum More...

static double	LAMBDA_MIN
	minimal value control parameter More...

static double	LAMBDA_MAX
	maximal value control parameter More...

static double	LAMBDA_UP
	multiplication factor control parameter More...

static double	LAMBDA_DOWN
	multiplication factor control parameter More...

static double	PIVOT
	minimal value diagonal element of Hesse matrix More...

static int	debug = 0
	debug level (default is off). More...

Detailed Description

template<>
struct JFIT::JRegressor< JPoint4D, JGandalf >

Regressor function object for JPoint4D fit using JGandalf minimiser.

Definition at line 43 of file JShowerBrightPointRegressor.hh.

Member Typedef Documentation

typedef JTOOLS::JSplineFunction1S_t JFIT::JRegressor< JPoint4D, JGandalf >::JFunction1D_t

Definition at line 48 of file JShowerBrightPointRegressor.hh.

typedef JTOOLS::JMAPLIST<JTOOLS::JPolint2FunctionalMap, JTOOLS::JPolint1FunctionalGridMap>::maplist JFIT::JRegressor< JPoint4D, JGandalf >::JPDFMapList_t

Definition at line 50 of file JShowerBrightPointRegressor.hh.

typedef JPHYSICS::JPDFTable<JFunction1D_t, JPDFMapList_t> JFIT::JRegressor< JPoint4D, JGandalf >::JPDF_t

Definition at line 51 of file JShowerBrightPointRegressor.hh.

typedef JGandalf <JPoint4D > JFIT::JAbstractRegressor< JPoint4D , JGandalf >::minimiser_type

inherited

Definition at line 80 of file JRegressor.hh.

typedef JRegressor<JPoint4D , JGandalf > JFIT::JAbstractRegressor< JPoint4D , JGandalf >::regressor_type

inherited

Definition at line 81 of file JRegressor.hh.

typedef minimiser_type::result_type JFIT::JAbstractRegressor< JPoint4D , JGandalf >::result_type

inherited

Definition at line 82 of file JRegressor.hh.

typedef JPoint4D ::parameter_type JFIT::JGandalf< JPoint4D >::parameter_type

inherited

Data type of fit parameter.

Definition at line 64 of file JGandalf.hh.

Constructor & Destructor Documentation

JFIT::JRegressor< JPoint4D, JGandalf >::JRegressor	(	const std::string &	fileDescriptor,
		const double	TTS,
		const int	numberOfPoints = `25`,
		const double	epsilon = `1.0e-10`
	)

inline

Parameterized constructor.

The PDF file descriptor should contain the wild card character JPHYSICS::WILDCARD which will be replaced by the corresponding PDF types.

Parameters

fileDescriptor	PDF file descriptor
TTS	TTS [ns]
numberOfPoints	number of points for Gauss-Hermite integration of TTS
epsilon	precision for Gauss-Hermite integration of TTS

Definition at line 65 of file JShowerBrightPointRegressor.hh.

                                                            :
       E_GeV(0.0)
     {
       using namespace std;
       using namespace JPP;
       
       const JPDF_t::JSupervisor supervisor(new JPDF_t::JDefaultResult(JMATH::zero));
       
       for (int i = 0; i != NUMBER_OF_PDFS; ++i) {
         
         try {
 
           const string file_name = getFilename(fileDescriptor, pdf_t[i]);
           
           NOTICE("loading PDF from file " << file_name << "... " << flush);
 
           pdf[i].load(file_name.c_str());
 
           NOTICE("OK" << endl);
 
           pdf[i].setExceptionHandler(supervisor);
         }
         catch(const JException& error) {
           FATAL(error.what() << endl);
         }
       }
 
       // Add PDFs
       for (int i = 1; i < NUMBER_OF_PDFS; i += 2) {
   
         pdf[ i ].add(pdf[i-1]); 
 
         JPDF_t buffer;
 
         pdf[i-1].swap(buffer);
         
         if        (TTS > 0.0) {
           pdf[i].blur(TTS, numberOfPoints, epsilon);
         } else if (TTS < 0.0) {
           ERROR("Illegal value of TTS [ns]: " << TTS << endl);
         }
       }    
     }

Member Function Documentation

template<class JHit_t >

result_type JFIT::JRegressor< JPoint4D, JGandalf >::operator()	(	const JPoint4D &	vx,
		const JHit_t &	hit
	)		const

inline

Fit function.

This method is used to determine the chi2 and gradient of given hit with respect a bright point emitting isotropically

JHit_t refers to a data structure which should have the following member methods:

double getX(); // [m]
double getY(); // [m]
double getZ(); // [m]
double getDX(); // [u]
double getDY(); // [u]
double getDZ(); // [u]
double getT(); // [ns]

Parameters

vx	shower vertex
hit	hit

Returns: chi2 and gradient

Definition at line 130 of file JShowerBrightPointRegressor.hh.

     {      
       using namespace JPP;
 
       JPosition3D  D(hit.getPosition());
       JDirection3D U(hit.getDirection());
 
       D.sub(vx.getPosition());
 
       double ct = U.getDot(D) / D.getLength();
 
       if (ct > +1.0) { ct = +1.0; }
       if (ct < -1.0) { ct = -1.0; }
 
       const double t  = vx.getT() + (D.getLength() * getIndexOfRefraction() * getInverseSpeedOfLight());
 
       const double dt = T_ns.constrain(hit.getT() - t);
 
       JPDF_t::result_type H0 = getH0(hit.getR(), dt);                // getH0 = Get background hypothesis value 
       JPDF_t::result_type H1 = getH1(D.getLength(), ct, dt, E_GeV);  // getH1 = Get signal hypothesis value
 
       if (get_value(H1) >= Vmax_npe) {
         H1 *= Vmax_npe / get_value(H1);
       }
 
       H1 += H0;  // now H1 is signal + background
 
       result_type result;
       
       result.chi2 = H1.getChi2() - H0.getChi2();  // Likelihood ratio
 
       /*
        * Here it is evaluated: d(chi2)/d(ct) * d(ct)/d(x0,y0,z0,t0)
        */
       result.gradient = JPoint4D(JVector3D(-getIndexOfRefraction() * D.getX() / D.getLength(),    // d(ct)/d(x0) 
                                            -getIndexOfRefraction() * D.getY() / D.getLength(),    // d(ct)/d(y0) 
                                            -getIndexOfRefraction() * D.getZ() / D.getLength()),   // d(ct)/d(z0) 
                                  getSpeedOfLight());                                              // d(ct)/d(t0)
       
       result.gradient.mul(getInverseSpeedOfLight() * (H1.getDerivativeOfChi2() -
                                                       H0.getDerivativeOfChi2()));                 // x d(chi2)/d(ct1)
 
       return result;
 
     }

JPDF_t::result_type JFIT::JRegressor< JPoint4D, JGandalf >::getH0	(	const double	R_Hz,
		const double	t1
	)		const

inline

Get background hypothesis value for time differentiated PDF.

Parameters

R_Hz	rate [Hz]
t1	time [ns]

Returns: hypothesis value

Definition at line 183 of file JShowerBrightPointRegressor.hh.

     {
       using namespace JPP;
 
       return JPDF_t::result_type(R_Hz * 1e-9, t1, T_ns);
     }

JPDF_t::result_type JFIT::JRegressor< JPoint4D, JGandalf >::getH1	(	const double	D,
		const double	ct,
		const double	t,
		const double	E
	)		const

inline

Get signal hypothesis value for bright point emission PDF.

Parameters

D	hit distance from shower vertex [m]
ct	cosine of the HIT angle
t	arrival time of the light
E	shower energy [GeV]

Returns: hypothesis value

Definition at line 200 of file JShowerBrightPointRegressor.hh.

     {
       using namespace JPP;
 
       JPDF_t::result_type h1 = JMATH::zero;
         
       for (int i = 0; i != NUMBER_OF_PDFS; ++i) {
 
         if (!pdf[i].empty() && D <= pdf[i].getXmax()) {
 
           try {
 
             JPDF_t::result_type y1 = E * pdf[i](std::max(D, pdf[i].getXmin()), ct, t);
             
             // safety measures
             
             if (y1.f <= 0.0) {
               y1.f  = 0.0;
               y1.fp = 0.0;
             }
             
             if (y1.v <= 0.0) {
               y1.v  = 0.0;
             }
             
             h1 += y1;
           
           }
           catch(JLANG::JException& error) {
             ERROR(error << std::endl);
           }
         }
       }
 
       return h1;
     }

double JFIT::JRegressor< JPoint4D, JGandalf >::getRmax ( ) const

inline

Get maximal road width of PDF.

Returns: road width [m]

Definition at line 245 of file JShowerBrightPointRegressor.hh.

     {
       using namespace JPP;
 
       double xmax = 0.0;
 
       for (int i = 0; i != NUMBER_OF_PDFS; ++i) {
 
         if (!pdf[i].empty() && pdf[i].getXmax() > xmax) {
           xmax = pdf[i].getXmax();
         }
         
       }
 
       return xmax;
     }

result_type JFIT::JAbstractRegressor< JPoint4D , JGandalf >::operator()	(	const JPoint4D &	value,
		T	__begin,
		T	__end
	)

inlineinherited

Global fit.

Parameters

value	start value
__begin	begin of data set
__end	end of data set

Returns: chi2

Definition at line 94 of file JRegressor.hh.

     {
       static_cast<minimiser_type&>(*this).value = value;
 
       return static_cast<minimiser_type&>(*this)(static_cast<regressor_type&>(*this), __begin, __end);
     }

result_type JFIT::JGandalf< JPoint4D >::operator()	(	const JFunction_t &	fit,
		T	__begin,
		T	__end,
		Args...	args
	)

inlineinherited

Multi-dimensional fit of multiple data sets.

The fit function should return the chi2 as well as the partial derivatives for the current value of the model and a given data point.

Parameters

fit	fit function
__begin	begin of data
__end	end of data
args	optional data

Returns: chi2 and gradient

Definition at line 129 of file JGandalf.hh.

     {
       using namespace std;
       using namespace JPP;
 
       // note that all model values should be assigned to the start value of the model before use
       // because the actual list of model parameters can vary from fit to fit
       // (e.g. if model consists of a container).
 
       const size_t N = parameters.size();
 
       V.resize(N);
       h.resize(N);
       x.resize(N);
 
       previous.result.chi2 = numeric_limits<double>::max();
 
       current.result.chi2     = numeric_limits<double>::max();
       current.result.gradient = value;
       current.result.gradient = zero;
 
       error     = value;
       error     = zero;
 
       lambda    = LAMBDA_MIN;
 
 
       for (numberOfIterations = 0; numberOfIterations != MAXIMUM_ITERATIONS; ++numberOfIterations) {
 
         DEBUG("step:     " << numberOfIterations << endl);
 
         reset();
 
         update(fit, __begin, __end, args...);
 
         DEBUG("lambda:   " << FIXED(12,5) << lambda              << endl);
         DEBUG("chi2:     " << FIXED(12,5) << current.result.chi2 << endl);
 
         if (current.result.chi2 < previous.result.chi2) {
 
           if (numberOfIterations != 0) {
 
             if (fabs(previous.result.chi2 - current.result.chi2) < EPSILON*fabs(previous.result.chi2)) {
 
               const result_type result = current.result;
 
               reset();
 
               update(fit, __begin, __end, args...);
 
               try {
                 V.invert();
               }
               catch (const exception& error) {
                 V.reset();
               }
 
               return result;                                        // normal end
             }
 
             if (lambda > LAMBDA_MIN) {
               lambda /= LAMBDA_DOWN;
             }
 
             // store current values
 
             previous.value  = value;
             previous.error  = error;
             previous.result = current.result;
           }
 
         } else {
 
           value   = previous.value;                                 // restore value
 
           lambda *= LAMBDA_UP;
           
           if (lambda > LAMBDA_MAX) {
             break;
           }
 
           reset();
 
           update(fit, __begin, __end, args...);
         }
 
         DEBUG("Hesse matrix:" << endl << V << endl);
 
         // force definite positiveness
 
         for (size_t i = 0; i != N; ++i) {
 
           if (V(i,i) < PIVOT) {
             V(i,i) = PIVOT;
           }
 
           h[i] = 1.0 / sqrt(V(i,i));
         }
 
         // normalisation
         
         for (size_t row = 0; row != N; ++row) {
           for (size_t col = 0; col != row; ++col) {
             V(row,col) *= h[row] * h[col];
             V(col,row)  = V(row,col);
           }
         }
         
         for (size_t i = 0; i != N; ++i) {
           V(i,i) = 1.0 + lambda;
         }
 
         // solve A x = b
 
         for (size_t col = 0; col != N; ++col) {
           x[col] = h[col] * get(current.result.gradient, parameters[col]);
         }
 
         try {
           V.solve(x);
         }
         catch (const exception& error) {
 
           ERROR("JGandalf: " << error.what() << endl << V << endl);
 
           break;
         }
 
         // update value and error
 
         for (size_t row = 0; row != N; ++row) {
 
           DEBUG("u[" << noshowpos << setw(3) << row << "] = " << showpos << FIXED(15,5) << get(value, parameters[row]));
 
           get(value, parameters[row]) -= h[row] * x[row];
           get(error, parameters[row])  = h[row];
 
           DEBUG(" -> " << FIXED(15,5) << get(value, parameters[row]) << noshowpos << endl);
         }
       }
 
       // abnormal end
 
       const result_type result = previous.result;
 
       value   = previous.value;                                     // restore value
       error   = previous.error;                                     // restore error
 
       reset();
 
       update(fit, __begin, __end, args...);
 
       try {
         V.invert();
       }
       catch (const exception& error) {
         V.reset();
       }
 
       return result;
     }