#include <DTDriftTimeParametrization.h>

Classes
struct	drift_time
	Structure used to return output values. More...

Public Member Functions
	DTDriftTimeParametrization ()
	Constructor. More...

unsigned short	MB_DT_drift_time (double x, double alpha, double by, double bz, short ifl, drift_time *DT, short interpolate) const
	Calculate drift time and spread. More...

virtual	~DTDriftTimeParametrization ()
	Destructor. More...

Private Member Functions
unsigned short	MB_DT_Check_boundaries (double distime, double alpha, double by, double bz, short ifl) const

double	MB_DT_delta_t (double, double *) const

void	MB_DT_Get_grid_points (double alpha, double by, double bz, unsigned short p_alpha, unsigned short p_By, unsigned short p_Bz, unsigned short q_alpha, unsigned short q_By, unsigned short q_Bz) const

void	MB_DT_Get_grid_values (double Var, unsigned short pi, unsigned short pj, short Initial, unsigned short N, const double *Values) const

double	MB_DT_MLInterpolation (double al, double by, double bz, double f) const

double	MB_DT_sigma_t_m (double, double *) const

double	MB_DT_sigma_t_p (double, double *) const

double	MB_DT_time (double, double *) const

Static Private Attributes
static const double	alpha_value [11]

static const double	By_value [5]

static const double	Bz_value [5]

static const double	fun_sigma_t [11][5][5][7]

static const double	fun_t [11][5][5][19]

static const double	velocitySkew

Detailed Description

Version 2.1 - November 18, 2003

MB_DT_drift_time() Calculates the drift time (ns)

See usage details in the README file delivered with the distribution.

Authors: Pablo Garcia-Abia and Jesus Puerta (CIEMAT, Madrid) Email: Pablo.nosp@m..Gar.nosp@m.cia@c.nosp@m.iema.nosp@m.t.es, Jesus.nosp@m..Pue.nosp@m.rta@c.nosp@m.iema.nosp@m.t.es

Definition at line 25 of file DTDriftTimeParametrization.h.

Constructor & Destructor Documentation

◆ DTDriftTimeParametrization()

DTDriftTimeParametrization::DTDriftTimeParametrization ( )

Constructor.

Definition at line 28 of file DTDriftTimeParametrization.cc.

28 {}

◆ ~DTDriftTimeParametrization()

DTDriftTimeParametrization::~DTDriftTimeParametrization ( )

virtual

Destructor.

Definition at line 30 of file DTDriftTimeParametrization.cc.

30 {}

Member Function Documentation

◆ MB_DT_Check_boundaries()

unsigned short DTDriftTimeParametrization::MB_DT_Check_boundaries	(	double	distime,
		double	alpha,
		double	by,
		double	bz,
		short	ifl
	)		const

private

Referenced by MB_DT_drift_time().

◆ MB_DT_delta_t()

double DTDriftTimeParametrization::MB_DT_delta_t	(	double	dist,
		double *	par
	)		const

private

Definition at line 208 of file DTDriftTimeParametrization.cc.

References x, and testProducerWithPsetDescEmpty_cfi::x2.

Referenced by MB_DT_drift_time().

                                                                                {
   double x2,
       x = fabs(dist);  // the parametrisations are symmetric under 'distance'
 
 #ifdef MB_DT_DEBUG
   printf("MB_DT_delta_t:  distance = %f\n", dist);
 #endif
 
   if (x > 20.5)
     x = 20.5;
 
   x2 = x * x;
 
   if (x <= par[15]) {
     return (par[1] + par[2] * x + par[3] * x2);
   }
   if (x <= par[16]) {
     return (par[4] + par[5] * x + par[6] * x2 + par[7] * x2 * x + par[8] * x2 * x2);
   }
   if (x <= par[17]) {
     return (par[9] + par[10] * x + par[11] * x2);
   }
   return (par[12] + par[13] * x + par[14] * x2);
 }

◆ MB_DT_drift_time()

unsigned short DTDriftTimeParametrization::MB_DT_drift_time	(	double	x,
		double	alpha,
		double	by,
		double	bz,
		short	ifl,
		drift_time *	DT,
		short	interpolate
	)		const

Calculate drift time and spread.

Definition at line 32 of file DTDriftTimeParametrization.cc.

References isotrackApplyRegressor::alpha, alpha_value, By_value, Bz_value, GeomDetEnumerators::DT, fun_sigma_t, fun_t, mps_fire::i, HiCaloJetParameters_cff::interpolate, dqmiolumiharvest::j, MB_DT_Check_boundaries(), MB_DT_delta_t(), MB_DT_Get_grid_points(), MB_DT_MLInterpolation(), MB_DT_sigma_t_m(), MB_DT_sigma_t_p(), MB_DT_time(), N_Par_t, N_Sigma_t, and x.

Referenced by DTDigitizer::driftTimeFromParametrization().

                                                                                                       {
   unsigned short i, j, n_func, ial, iby, ibz;
   unsigned short i_alpha, i_By, i_Bz;
   unsigned short j_alpha, j_By, j_Bz;
 
   double dist;
   double OffSet;
   double par_t[N_Par_t];
   double par_sigma_t[N_Sigma_t];
 
   double V_al[3], V_by[3], V_bz[3];
 
   double DTV_v_drift[N_Func];
   double DTV_t_drift[N_Func];
   double DTV_delta_t[N_Func];
   double DTV_t_width_m[N_Func];
   double DTV_t_width_p[N_Func];
 
   DT->v_drift = -1;
   DT->t_drift = -1;
   DT->delta_t = -1;
   DT->t_width_m = -1;
   DT->t_width_p = -1;
 
   /* Check 'interpolate' and initialize DTV */
 
   switch (interpolate) {
     case 1:
       n_func = N_Func;
       for (j = 0; j < N_Func; j++) {
         DTV_v_drift[j] = -1;
         DTV_t_drift[j] = -1;
         DTV_delta_t[j] = -1;
         DTV_t_width_m[j] = -1;
         DTV_t_width_p[j] = -1;
       }
       break;
 
     case 0:
       n_func = 1;
       break;
 
     default:
       printf("*** ERROR, MB_DT_drift_time:  invalid interpolate value = %d\n", interpolate);
       return (0);
   }
 
 #ifdef MB_DT_DEBUG
 
   /* Dump input values */
 
   printf("\nMB_DT_drift_time:  Function called with values:\n\n");
   printf("MB_DT_drift_time:    x     = %f\n", x);
   printf("MB_DT_drift_time:    alpha = %f\n", alpha);
   printf("MB_DT_drift_time:    by    = %f\n", by);
   printf("MB_DT_drift_time:    bz    = %f\n", bz);
   printf("MB_DT_drift_time:    ifl   = %d\n", ifl);
 
 #endif
 
   /* Take into account the symmetries of the parametrisations */
 
   if (ifl < 0) {
     printf("*** ERROR, MB_DT_drift_time:  invalid ifl value = %d\n", ifl);
     return (0);
   }
 
   dist = (ifl == 0) ? x : x - DT_Cell_HalfWidth;  // dist = [-21,21] mm
 
   by = fabs(by);  //  f (By) = f (-By)
 
   if (bz < 0) {  //  f (alpha, Bz) = f (-alpha, -Bz)
     bz = -bz;
     alpha = -alpha;
   }
 
   /* Check boundaries of the variables and take the closest values */
 
   MB_DT_Check_boundaries(dist, alpha, by, bz, ifl);
 
   MB_DT_Get_grid_points(alpha, by, bz, &i_alpha, &i_By, &i_Bz, &j_alpha, &j_By, &j_Bz);
 
 #ifdef MB_DT_DEBUG
   printf("MB_DT_drift_time:\n");
   printf("MB_DT_drift_time:  i_alpha j_alpha alpha_value's %d %d %.0f %.0f\n",
          i_alpha,
          j_alpha,
          alpha_value[i_alpha],
          alpha_value[j_alpha]);
   printf(
       "MB_DT_drift_time:  i_By    j_By    By_value's    %d %d %.2f %.2f\n", i_By, j_By, By_value[i_By], By_value[j_By]);
   printf(
       "MB_DT_drift_time:  i_Bz    j_Bz    Bz_value's    %d %d %.2f %.2f\n", i_Bz, j_Bz, Bz_value[i_Bz], Bz_value[j_Bz]);
 #endif
 
   /* Get the parametrisations for the different grid points */
 
   for (j = 0; j < n_func; j++) {
     ial = (j & 4) ? j_alpha : i_alpha;
     iby = (j & 2) ? j_By : i_By;
     ibz = (j & 1) ? j_Bz : i_Bz;
 
     for (i = 0; i < N_Par_t; i++)
       par_t[i] = fun_t[ial][iby][ibz][i];
     for (i = 0; i < N_Sigma_t; i++)
       par_sigma_t[i] = fun_sigma_t[ial][iby][ibz][i];
 
     OffSet = par_t[N_Par_t - 1];
 
     DTV_v_drift[j] = par_t[0];                                           // drift velocity
     DTV_delta_t[j] = MB_DT_delta_t(dist, par_t);                         // deviation from linearity
     DTV_t_drift[j] = MB_DT_time(dist, par_t) + DTV_delta_t[j] + OffSet;  // drift time
     DTV_t_width_m[j] = MB_DT_sigma_t_m(dist, par_sigma_t);               // time width (minus, left)
     DTV_t_width_p[j] = MB_DT_sigma_t_p(dist, par_sigma_t);               // time width (plus, right)
 
 #ifdef MB_DT_DEBUG
     printf("MB_DT_drift_LOOP: OffSet = %f\n", OffSet);
     printf(
         "MB_DT_drift_LOOP: dist, v_drift, t_drift, lin, t_width_m, "
         "t_width_p = %f %f %f %f %f %f\n",
         dist,
         DTV_v_drift[j],
         DTV_t_drift[j],
         DTV_delta_t[j],
         DTV_t_width_m[j],
         DTV_t_width_p[j]);
 #endif
   }
 
   /* Return interpolated or grid values */
 
   if (interpolate == 0) {
     DT->v_drift = DTV_v_drift[0];
     DT->delta_t = DTV_delta_t[0];
     DT->t_drift = DTV_t_drift[0];
     DT->t_width_m = DTV_t_width_m[0];
     DT->t_width_p = DTV_t_width_p[0];
   } else {
     V_al[0] = alpha;
     V_al[1] = alpha_value[i_alpha];
     V_al[2] = alpha_value[j_alpha];
     V_by[0] = by;
     V_by[1] = By_value[i_By];
     V_by[2] = By_value[j_By];
     V_bz[0] = bz;
     V_bz[1] = Bz_value[i_Bz];
     V_bz[2] = Bz_value[j_Bz];
 
     DT->v_drift = MB_DT_MLInterpolation(V_al, V_by, V_bz, DTV_v_drift);
     DT->delta_t = MB_DT_MLInterpolation(V_al, V_by, V_bz, DTV_delta_t);
     DT->t_drift = MB_DT_MLInterpolation(V_al, V_by, V_bz, DTV_t_drift);
     DT->t_width_m = MB_DT_MLInterpolation(V_al, V_by, V_bz, DTV_t_width_m);
     DT->t_width_p = MB_DT_MLInterpolation(V_al, V_by, V_bz, DTV_t_width_p);
   }
 
 #ifdef MB_DT_DEBUG
   printf(
       "MB_DT_drift_time: dist, v_drift, t_drift, lin, t_width_m, t_width_p "
       "= %f %f %f %f %f %f\n",
       dist,
       DT->v_drift,
       DT->t_drift,
       DT->delta_t,
       DT->t_width_m,
       DT->t_width_p);
 #endif
 
   return (1);
 }

◆ MB_DT_Get_grid_points()

void DTDriftTimeParametrization::MB_DT_Get_grid_points	(	double	alpha,
		double	by,
		double	bz,
		unsigned short *	p_alpha,
		unsigned short *	p_By,
		unsigned short *	p_Bz,
		unsigned short *	q_alpha,
		unsigned short *	q_By,
		unsigned short *	q_Bz
	)		const

private

Referenced by MB_DT_drift_time().

◆ MB_DT_Get_grid_values()

void DTDriftTimeParametrization::MB_DT_Get_grid_values	(	double	Var,
		unsigned short *	pi,
		unsigned short *	pj,
		short	Initial,
		unsigned short	N,
		const double *	Values
	)		const

private

◆ MB_DT_MLInterpolation()

double DTDriftTimeParametrization::MB_DT_MLInterpolation	(	double *	al,
		double *	by,
		double *	bz,
		double *	f
	)		const

private

Referenced by MB_DT_drift_time().

◆ MB_DT_sigma_t_m()

double DTDriftTimeParametrization::MB_DT_sigma_t_m	(	double	,
		double *
	)		const

private

Referenced by MB_DT_drift_time().

◆ MB_DT_sigma_t_p()

double DTDriftTimeParametrization::MB_DT_sigma_t_p	(	double	,
		double *
	)		const

private

Referenced by MB_DT_drift_time().

◆ MB_DT_time()

double DTDriftTimeParametrization::MB_DT_time	(	double	dist,
		double *	par
	)		const

private

Definition at line 203 of file DTDriftTimeParametrization.cc.

Referenced by MB_DT_drift_time().

                                                                             {
   return (fabs(dist) / par[0]);  // par[0] is the drift velocity, 'time' is the
                                  // linear part of the drift time
 }