GETSignalFunctions.hh

Go to the documentation of this file.

//======================================================================
/*! \file GETSignalFunctions.hh
 *
 *  Include file for signal analysis functions.
 */
//======================================================================

#ifndef GET_SIGNAL_FUNCTIONS_HH
#define GET_SIGNAL_FUNCTIONS_HH

//----------------------------------------------------------------------

#include "GETChannel.hh"

//! Value of sqrt(2*pi) constant
#define GET_SQRT_2PI    2.506628274631000241612

//! Conversion factor from standard deviation to FWHM
#define GET_SIGMA_TO_FWHM   2.354820045030949327014013761072419583797L

//! Conversion factor from FWHM to standard deviation
#define GET_FWHM_TO_SIGMA   0.424660900144009534340483469350147061050L

//----------------------------------------------------------

// global variable for integration step.
extern u_int  getIntegPoints;
extern double getIntegStep;

// global variables for convolution with the GSC function
extern u_int  getGSCConvPoints;
extern double getGSCConvWidth;


//----------------------------------------------------------
/** @name Base function */
//@{

extern double GETGaus ( const double x[], const double p[] ); // inline
extern double GETGaus ( double t, double srf, double ctr, double sig );

extern double GETSinC ( const double x[], const double p[] ); // inline
extern double GETSinC ( double t, double srf, double ctr, double scw );

extern double GETSquare ( const double x[], const double p[] );
extern double GETSquare ( double t, double srf, double ctr, double wid );

extern double GETGausSinC ( const double x[], const double p[] ); // inline
extern double GETGausSinC ( double t, double srf, double ctr, double sig, double w );
//@}


//----------------------------------------------------------
/** @name Functions for fitting the signals */
//@{

// convolution of a centered square distribution with a Gauss or GSC function
extern double GETSquareGaus ( const double x[], const double p[] );   // inline
extern double GETSquareGaus ( double t, double srf, double ctr, double wid, double sig, double bg );

extern double GETSquareSinC ( const double x[], const double p[] );   // inline
extern double GETSquareSinC ( double t, double srf, double ctr, double wid, double scw, double bg );

extern double GETSquareGSC  ( const double x[], const double p[] );   // inline
extern double GETSquareGSC  ( double t, double srf, double ctr, double wid, double sig, double scw, double bg );


//    --- obsolete functions ---
extern double GETConvolutionSinC ( double t, double scw,
                                   double(*fct)(const double[], const double[]),
                                   const double pf[] );
extern double GETConvolutionGSC ( double t, double sig, double scw,
                                  double(*fct)(const double[], const double[]),
                                  const double pf[] );

//    --- obsolete functions ---
// convolution of a square distribution with a Gauss function
extern double GETSquareCurrent     ( const double x[], const double p[] );
extern double GETSquareCurrentGaus ( const double x[], const double p[] );
extern double GETSquareCurrentGSC  ( const double x[], const double p[] );

//    --- obsolete functions ---
// same as the previous one, but the time information is the dist. center
extern double GETSquareCurrent2     ( const double x[], const double p[] );
extern double GETSquareCurrent2Gaus ( const double x[], const double p[] );
extern double GETSquareCurrent2GSC  ( const double x[], const double p[] );

//@}

//======================================================================
//  Inline functions

/*! Gaus function with integral parameter.
 *  - p[0] integral
 *  - p[1] center
 *  - p[2] sigma
 *  \param  x     array of coordinates (only x[0] is used)
 *  \param  p     array of parameters
 */
inline double GETGaus ( const double x[], const double p[] )
  { return ( GETGaus (x[0], p[0], p[1], p[2]) ); }

/*! SinC function with integral parameter.
 *  - p[0] integral
 *  - p[1] center
 *  - p[2] scale factor
 *  \param  x     array of coordinates (only x[0] is used)
 *  \param  p     array of parameters
 */
inline double GETSinC ( const double x[], const double p[] )
  { return ( GETSinC (x[0], p[0], p[1], p[2]) ); }

/*! Function for a square current distribution.
 *  - p[0]    total charge: time width multiplied by the current value
 *  - p[1]    distribution center time
 *  - p[2]    width of the square current
 *  \param  x   coordinates array (only 1 used)
 *  \param  p   parameters array
 */
inline double GETSquare ( const double x[], const double p[] )
  { return ( GETSquare (x[0], p[0], p[1], p[2]) ); }

/*! Product of a Gaus function with sinc function: G(x) * sin(x/w) / (x/w).
 *  - p[0] amplitude
 *  - p[1] center
 *  - p[2] sigma
 *  - p[3] sin cardinal dilatation factor
 *  \param  x     array of coordinates (only x[0] is used)
 *  \param  p     array of parameters
 */
inline double GETGausSinC ( const double x[], const double p[] )
  { return ( GETGausSinC (x[0], p[0], p[1], p[2], p[3]) ); }

/*! Function for a square current distribution, convoluted with
 *  a gaus function (smoothing).
 *  - p[0]    total charge: time width multiplied by the current value
 *  - p[1]    distribution center time
 *  - p[2]    width of the square current
 *  - p[3]    sigma of the convolution gaus function
 *  - p[4]    offset (background)
 *  \param  x     array of coordinates (only x[0] is used)
 *  \param  p     array of parameters
 */
inline double GETSquareGaus ( const double x[], const double p[] )
  { return ( GETSquareGaus (x[0], p[0], p[1], p[2], p[3], p[4]) ); }

/*! Function for a square current distribution, convoluted with
 *  a SinC function.
 *  - p[0]    total charge: time width multiplied by the current value
 *  - p[1]    distribution center time
 *  - p[2]    width of the square current
 *  - p[3]    sinc coordinate factor
 *  - p[4]    offset (background)
 *  \param  x   coordinates array (only 1 used)
 *  \param  p   parameters array
 */
inline double GETSquareSinC ( const double x[], const double p[] )
  { return ( GETSquareSinC (x[0], p[0], p[1], p[2], p[3], p[4] ) ); }

/*! Function for a square current distribution, convoluted with
 *  a Gaus x SinC function.
 *  - p[0]    total charge: time width multiplied by the current value
 *  - p[1]    distribution center time
 *  - p[2]    width of the square current
 *  - p[3]    sigma of the convolution gaus function
 *  - p[4]    sinc coordinate factor
 *  - p[5]    offset (background)
 *  \param  x   coordinates array (only 1 used)
 *  \param  p   parameters array
 */
inline double GETSquareGSC ( const double x[], const double p[] )
  { return ( GETSquareGSC (x[0], p[0], p[1], p[2], p[3], p[4], p[5]) ); }

//----------------------------------------------------------------------
#endif