#include <TFParams.h>

Inheritance diagram for TFParams:

Public Member Functions
double	computePulseWidth (int, double, double)

void	copie_colonne_mat (matrice, matrice, int)

void	diff_mat (matrice, matrice, matrice)

double	f3deg (int, double parom[dimout], double mask[dimmat], double adcpj[dimmat], double errpj[dimmat][dimmat])

double	fitpj (double *, double , double **, double noise_val, int debug)

double	inv3x3 (double a[3][3], double b[3][3])

double	inverpj (int, double g[dimmat][dimmat], double ginv[dimmat][dimmat])

void	inverse_mat (matrice, matrice)

double	lastShape (Double_t , Double_t )

double	lastShape2 (Double_t , Double_t )

double	mixShape (Double_t , Double_t )

double	parab (double , Int_t, Int_t, double )

Double_t	polfit (Int_t ns, Int_t imax, Double_t par3d[dimout], Double_t errpj[dimmat][dimmat], double *)

void	print_mat (matrice)

void	print_mat_nk (matrice, int)

void	produit_mat (matrice, matrice, matrice)

void	produit_mat_int (matrice, matrice, matrice)

double	pulseShapepj (Double_t , Double_t )

double	pulseShapepj2 (Double_t , Double_t )

void	set_const (int, int, int, double, double, int)

void	somme_mat_int (matrice, matrice)

void	somme_mat_int_scale (matrice, matrice, double)

	TFParams (int size=SDIM2, int size_sh=PLSHDIM)

void	transpose_mat (matrice, matrice)

void	zero_mat (matrice)

void	zero_mat_nk (matrice, int)

	~TFParams () override

Public Attributes
char	name_mat [10]

Static Public Attributes
static constexpr unsigned int	dimmat = 30

static constexpr unsigned int	dimout = 10

static constexpr unsigned int	nbmax_cell = 1000

static constexpr int	PLSHDIM = 650

static constexpr int	SDIM2 = 10

Private Attributes
double	a1ini

double	a2ini

double	a3ini

double	adclu [26]

int	METHODE

int	nevtmax

int	ns

int	nsmax

int	nsmin

double	step_shape

double	weight_matrix [10][10]

Detailed Description

Definition at line 38 of file TFParams.h.

Constructor & Destructor Documentation

TFParams::TFParams	(	int	size = `SDIM2`,
		int	size_sh = `PLSHDIM`
	)

Definition at line 23 of file TFParams.cc.

References mps_fire::i, and dqmiolumiharvest::j.

                                         {
   //int  sdim = size;
   //int plshdim = size_sh;
 
   for (int i = 0; i < 10; i++) {
     for (int j = 0; j < 10; j++) {
       weight_matrix[i][j] = 8.;
     }
   }
 }

TFParams::~TFParams ( )

inlineoverride

Definition at line 63 of file TFParams.h.

63 {};

Member Function Documentation

double TFParams::computePulseWidth	(	int	methode,
		double	alpha_here,
		double	beta_here
	)

Definition at line 1158 of file TFParams.cc.

References dt, testEve_cfg::level, and hltrates_dqm_sourceclient-live_cfg::offset.

                                                                                    {
   // level of amplitude where we calculate the width ( level = 0.5 if at 50 % )
   //   (level = 0.3 if at 30 % )
   double level = 0.30;
   // fixed parameters
   double amplitude = 1.00;
   double offset = 7.00;
   double amp_max = amplitude;
 
   // steps in time
   double t_min = offset - 4.50;
   double t_max = offset + 12.50;
 
   int t_step_max = 3000;
   double delta_t = (double)((t_max - t_min) / t_step_max);
 
   // Loop over time ( Loop 2  --> get width )
   int t_amp_half_flag = 0;
   double t_amp_half_min = 999.;
   double t_amp_half_max = -999.;
 
   for (int t_step = 0; t_step < t_step_max; t_step++) {
     double t_val = t_min + (double)t_step * delta_t;
     double albet = alpha_here * beta_here;
     double dt = t_val - offset;
     double amp = 0;
 
     if (methode == 2) {  // electronic function
       if ((t_val - offset) > -albet) {
         amp = amplitude * TMath::Power((1 + (dt / (alpha_here * beta_here))), alpha_here) *
               TMath::Exp(-1.0 * (dt / beta_here));
       } else {
         amp = 1.;
       }
     }
 
     if (amp > (amp_max * level) && t_amp_half_flag == 0) {
       t_amp_half_flag = 1;
       t_amp_half_min = t_val;
     }
 
     if (amp < (amp_max * level) && t_amp_half_flag == 1) {
       t_amp_half_flag = 2;
       t_amp_half_max = t_val;
     }
   }
 
   // Compute Width
   double width = (t_amp_half_max - t_amp_half_min);
 
   return width;
 }

void TFParams::copie_colonne_mat	(	matrice	A,
		matrice	M,
		int	nk
	)

Definition at line 579 of file TFParams.cc.

References matrice::coeff, mps_fire::i, dqmiolumiharvest::j, isotrackApplyRegressor::k, matrice::nb_colonnes, matrice::nb_lignes, and gpuVertexFinder::printf().

                                                              {
   int i, j;
   int k;
   /* resultat de la copie de A dans un vecteur colonne M */
   k = 0;
   for (i = 0; i < A.nb_lignes; i++) {
     for (j = 0; j < A.nb_colonnes; j++) {
       M.coeff[nk][k] = A.coeff[i][j];
       printf(" copie nk %d  i %d j %d k %d A %e M %e \n ", nk, i, j, k, A.coeff[i][j], M.coeff[nk][k]);
       k++;
     }
   }
   return;
 }

void TFParams::diff_mat	(	matrice	A,
		matrice	B,
		matrice	M
	)

Definition at line 562 of file TFParams.cc.

References matrice::coeff, mps_fire::i, dqmiolumiharvest::j, matrice::nb_colonnes, matrice::nb_lignes, and gpuVertexFinder::printf().

                                                        {
   int i, j;
   //resultat de la difference A-B = M
   if (A.nb_lignes != B.nb_lignes) {
     printf(" Erreur : difference de matrices de tailles incompatibles \n ");
     M.coeff = nullptr;
     return;
   }
   M.nb_lignes = A.nb_lignes;
   M.nb_colonnes = A.nb_colonnes;
   for (i = 0; i < M.nb_lignes; i++) {
     for (j = 0; j < M.nb_colonnes; j++) {
       M.coeff[i][j] = A.coeff[i][j] - B.coeff[i][j];
     }
   }
   return;
 }

double TFParams::f3deg	(	int	nmxu,
		double	parom[dimout],
		double	mask[dimmat],
		double	adcpj[dimmat],
		double	errpj[dimmat][dimmat]
	)

Definition at line 805 of file TFParams.cc.

References CommonMethods::delta(), validate-o2o-wbm::f, h, mps_fire::i, isotrackApplyRegressor::k, cmsLHEtoEOSManager::l, alignCSCRings::s, mathSSE::sqrt(), submitPVValidationJobs::t, and createJobs::tmp.

                                                                                                              {
   /*                                                                   */
   /*  fit   3rd degree polynomial                                      */
   /*  nmxu = nb of samples in sample data array adcpj[]
     parom   values of parameters
     errpj  inverse of the error matrix
     fplo3dg uses only the diagonal terms of errpj[][]
 */
   int i, k, l /*,iworst*/;
   double h, t2, tm, delta, tmp;
   double xki2, dif, difmx, deglib;
   double t[dimmat], f[dimmat][4];
   double cov[dimmat][dimmat], bv[4], invcov[dimmat][dimmat], s /*, deter*/;
 
   deglib = (double)nmxu - 4.;
   for (i = 0; i < nmxu; i++) {
     t[i] = i;
     f[i][0] = 1.;
     f[i][1] = t[i];
     f[i][2] = t[i] * t[i];
     f[i][3] = f[i][2] * t[i];
   }
   /*   computation of covariance matrix     */
   for (k = 0; k < 4; k++) {
     for (l = 0; l < 4; l++) {
       s = 0.;
       for (i = 0; i < nmxu; i++) {
         s = s + f[i][k] * f[i][l] * errpj[i][i] * mask[i];
       }
       cov[k][l] = s;
     }
     s = 0.;
     for (i = 0; i < nmxu; i++) {
       s = s + f[i][k] * adcpj[i] * errpj[i][i] * mask[i];
     }
     bv[k] = s;
   }
   /*     parameters                          */
   /*deter =*/inverpj(4, cov, invcov);
   for (k = 0; k < 4; k++) {
     s = 0.;
     for (l = 0; l < 4; l++) {
       s = s + bv[l] * invcov[l][k];
     }
     parom[k] = s;
   }
 
   if (parom[3] == 0.) {
     parom[4] = -1000.;
     parom[5] = -1000.;
     parom[6] = -1000.;
     return 1000000.;
   }
   /*    worst hit and ki2                    */
   xki2 = 0.;
   difmx = 0.;
   for (i = 0; i < nmxu; i++) {
     t2 = t[i] * t[i];
     h = parom[0] + parom[1] * t[i] + parom[2] * t2 + parom[3] * t2 * t[i];
     dif = (adcpj[i] - h) * mask[i];
     if (dif > difmx) {
       // iworst=i  ;
       difmx = dif;
     }
   }
   if (deglib > 0.5)
     xki2 = xki2 / deglib;
   /*     amplitude and maximum position                    */
   delta = parom[2] * parom[2] - 3. * parom[3] * parom[1];
   if (delta > 0.) {
     delta = sqrt(delta);
     tm = -(delta + parom[2]) / (3. * parom[3]);
     tmp = (delta - parom[2]) / (3. * parom[3]);
   } else {
     parom[4] = -1000.;
     parom[5] = -1000.;
     parom[6] = -1000.;
     return xki2;
   }
   parom[4] = tm;
   parom[5] = parom[0] + parom[1] * tm + parom[2] * tm * tm + parom[3] * tm * tm * tm;
   parom[6] = tmp;
   // printf("par --------> %f %f %f %f \n",parom[3],parom[2],parom[1],parom[0]);
 
   return xki2;
 }

double TFParams::fitpj	(	double **	adcval,
		double *	parout,
		double **	db_i,
		double	noise_val,
		int	debug
	)

Definition at line 34 of file TFParams.cc.

References isotrackTrainRegressor::a1, isotrackTrainRegressor::a2, alpha, TtFullHadDaughter::B, b1, b2, HLT_FULL_cff::beta, gen::C, HLT_FULL_cff::chi2, matrice::coeff, gather_cfg::cout, cree_mat(), cree_mat_prod(), dqmPostProcessing_online::DB, CommonMethods::delta(), dt, mps_fire::i, dqmiolumiharvest::j, isotrackApplyRegressor::k, relval_steps::k2, log, nevt, nsamp, ntrack, gpuVertexFinder::printf(), submitPVValidationJobs::t, X, BeamSpotPI::Y, and BeamSpotPI::Z.

Referenced by TShapeAnalysis::computeShape().

                                                                                                   {
 #define dimn 10
 #define dimin 10
 #define plshdim 300
 #define nsamp 10
 #define ntrack 500
   //#define debug debug1
 
   // ******************************************************************
   // *  Definitions of variables used in the routine
   // ******************************************************************
 
   double a1, a2, a3, b1, b2;
   int iter, nevt;
   //double errpj[dimmat][dimmat]  ;
   double bi[ntrack][2], dbi[ntrack][2];
   double zi[ntrack][2];
   double par3degre[3];
   int ioktk[ntrack], nk, nborn_min = 0, nborn_max = 0;
   double cti[ntrack][6], dm1i[ntrack][4];
   double par[4], tsig[1];
   double amp, delta[nsamp], delta2, fun;
   double num_fit_min[ntrack], num_fit_max[ntrack];
   int i, j, k, imax[ntrack];
 
   double ampmax[ntrack], dt, t;
   double chi2, chi2s, da1[nsamp], da2[nsamp], db1[nsamp], db2[nsamp];
   double chi2tot;
   double fact2;
   double albet, dtsbeta, variab, alpha, beta;
   double unsurs1 /*,unsurs2*/;
   //  double fit3 ;
   int numb_a, numb_b, numb_x;
 
   fun = 0;
   chi2s = 0;
   chi2tot = 0;
   matrice DA, DAT, BK, DB, DBT, C, CT, D, DM1, CDM1, CDM1CT, Z, CDM1Z, YK, Y, B, X, XINV, RES2;
   matrice A_CROISS, ZMCT;
 
   double *amplu;
   amplu = new double[nsamp];
 
   parout[0] = 0.;
   parout[1] = 0.;
   parout[2] = 0.;
 
   //
   //  Initialisation of fit parameters
   //
 
   a1 = a1ini;
   a2 = a2ini;
   a3 = a3ini;
   if (METHODE == 2) {
     a2 = a3ini;  // for lastshape BETA is the third parameter ( ... ! )
   }
   if (debug == 1) {
     printf(" ------> __> valeurs de a1 %f a2 %f a3 %f\n", a1, a2, a3);
   }
   for (i = 0; i < ntrack; i++) {
     for (j = 0; j < 2; j++) {
       bi[i][j] = (double)0.;
       dbi[i][j] = (double)0.;
       zi[i][j] = (double)0.;
       cti[i][j] = (double)0.;
       dm1i[i][j] = (double)0.;
     }
   }
 
   numb_a = 2;
 
   //
   //  Matrices initialisation
   //
 
   numb_x = 1;
   numb_b = 2;
   DA = cree_mat(numb_a, numb_x);
   DAT = cree_mat(numb_x, numb_a);
   BK = cree_mat_prod(DA, DAT);
   DB = cree_mat(numb_b, numb_x);
   DBT = cree_mat(numb_x, numb_b);
   C = cree_mat(numb_a, numb_b);
   CT = cree_mat(numb_b, numb_a);
   D = cree_mat_prod(DB, DBT);
   DM1 = cree_mat_prod(DB, DBT);
   CDM1 = cree_mat_prod(C, DM1);
   CDM1CT = cree_mat_prod(CDM1, CT);
   Z = cree_mat(numb_b, numb_x);
   CDM1Z = cree_mat_prod(CDM1, Z);
   YK = cree_mat(numb_a, numb_x);
   Y = cree_mat(numb_a, numb_x);
   B = cree_mat_prod(DA, DAT);
   X = cree_mat_prod(DA, DAT);
   XINV = cree_mat_prod(DA, DAT);
   RES2 = cree_mat(numb_a, numb_x);
   A_CROISS = cree_mat(numb_a, numb_x);
   ZMCT = cree_mat(numb_b, numb_x);
 
   // First Loop on iterations //
 
   for (iter = 0; iter < 6; iter++) {
     chi2tot = 0;
 
     //
     //    Set zeros for general matrices
     //
 
     if (debug == 1) {
       printf(" Debut de l'iteration numero %d \n", iter);
     }
     zero_mat(CDM1Z);
     zero_mat(Y);
     zero_mat(CDM1CT);
     zero_mat(B);
     zero_mat(X);
     zero_mat(CDM1);
 
     nk = -1;
     if (debug == 1) {
       printf(" resultats injectes a iterations %d \n", iter);
       printf(" parametre a1 = %f \n", a1);
       printf(" parametre a2 = %f \n", a2);
       printf(" chi2 du fit chi2s = %f \n", chi2s);
 
       printf(" value de nevtmax _______________ %d \n", nevtmax);
     }
 
     //  Loop on events //
 
     for (nevt = 0; nevt < nevtmax; nevt++) {
       //       B1 = BI[nk,1] est la normalisation du signal
       //       B2 = BI[nk,2] ewst le dephasage par rapport a une
       //                 fonction centree en zero
       //        Nous choisissons ici de demarrer avec les resultats
       //            de l'ajustement parabolique mais il faudra bien
       //            entendu verifier que cela ne biaise pas le resultat !
       //            mise a zero des matrices utilisees dans la boucle
 
       zero_mat(Z);
       zero_mat(YK);
       zero_mat(BK);
       zero_mat(C);
       zero_mat(D);
 
       nk = nevt;
       ampmax[nk] = 0.;
       imax[nk] = 0;
       for (k = 0; k < 10; k++) {
         amplu[k] = adcval[nevt][k];
         if (amplu[k] > ampmax[nk]) {
           ampmax[nk] = amplu[k];
           imax[nk] = k;
         }
       }
 
       if (iter == 0) {
         // start with degree 3 polynomial ....
         //fit3 =polfit(ns ,imax[nk] ,par3degre ,errpj ,amplu ) ;
         //  std::cout << "Poly Fit Param  :"<< par3degre[0] <<" "<< par3degre[1]<< std::endl;
 
         // start with parabol
         //fit3 = parab(amplu,4,12,par3degre) ;
         /*fit3 =*/parab(amplu, 2, 9, par3degre);
         //std::cout << "Parab Fit Param :"<< par3degre[0] <<" "<< par3degre[1]<< std::endl;
 
         // start with basic initial values
         //par3degre[0]= ampmax+ampmax/10. ;
         //par3degre[1]= (double)imax[nk]+0.1 ;
         //bi[nk][0] = ampmax[nk] ;
         //bi[nk][1] = (double)imax[nk] ;
 
         num_fit_min[nevt] = (double)imax[nk] - (double)nsmin;
         num_fit_max[nevt] = (double)imax[nk] + (double)nsmax;
 
         bi[nk][0] = par3degre[0];
         bi[nk][1] = par3degre[1];
 
         if (debug == 1) {
           printf("---------> depart ampmax[%d]=%f   maximum %f tim %f \n", nk, ampmax[nk], bi[nk][0], bi[nk][1]);
         }
 
       } else {
         //  in other iterations  :
         //   increment bi[][] parameters with bdi[][]
         //   calculated in previous
         //   iteration
 
         bi[nk][0] += dbi[nk][0];
         bi[nk][1] += dbi[nk][1];
 
         if (debug == 1) {
           printf("iter %d valeur de max %f et norma %f poly 3 \n", iter, bi[nk][1], bi[nk][0]);
         }
       }
 
       b1 = bi[nk][0];
       b2 = bi[nk][1];
 
       // Loop on samples //
 
       chi2 = 0.;
       ioktk[nk] = 0;
       ns = nborn_max - nborn_min + 1;
 
       for (k = 0; k < 10; k++) {
         //
         //  calculation of fonction used to fit
         //
 
         dt = (double)k - b2;
         t = (double)k;
         amp = amplu[k];
         if (debug == 1) {
           printf(" CHECK sample %f ampli %f \n", t, amp);
         }
         //unsurs1 = 1./sig_err ;
         //unsurs2 = 1./(sig_err*sig_err) ;
         //unsurs1 = 0.1 ;
         //unsurs2 = 0.01 ;
 
         unsurs1 = 1. / noise_val;
         //unsurs2=(1./noise_val)*(1./noise_val);
 
         //
         // Pulse shape function used: pulseShapepj
         //
 
         nborn_min = (int)num_fit_min[nevt];
         nborn_max = (int)num_fit_max[nevt];
         if (k < nborn_min || k > nborn_max)
           continue;
         tsig[0] = (double)k;
 
         if (METHODE == 2) {
           par[0] = b1;
           par[1] = b2;
           par[2] = a1;
           par[3] = a2;
           fun = pulseShapepj(tsig, par);
         }
         if (debug == 1) {
           printf(" valeur ampli %f et function %f min %d max %d \n", amp, fun, nsmin, nsmax);
           printf("min %f max %f \n", num_fit_min[nevt], num_fit_max[nevt]);
         }
 
         //   we need to determine a1,a2 which are global parameters
         //    and  b1, b2 which are parameters for each individual signal:
         //        b1, b2 = amplitude and time event by event
         //        a1, a2 = alpha and beta global
         //    we first begin to calculate the derivatives used in the following calculation
 
         if (METHODE == 2) {
           alpha = a1;
           beta = a2;
           albet = alpha * beta;
           if (dt > -albet) {
             variab = (double)1. + dt / albet;
             dtsbeta = dt / beta;
             db1[k] = unsurs1 * fun / b1;
             fact2 = fun;
             db2[k] = unsurs1 * fact2 * dtsbeta / (albet * variab);
             da1[k] = unsurs1 * fact2 * (log(variab) - dtsbeta / (alpha * variab));
             da2[k] = unsurs1 * fact2 * dtsbeta * dtsbeta / (albet * variab);
           }
         }
         delta[k] = (amp - fun) * unsurs1;
         if (debug == 1) {
           printf(" ------->iter %d valeur de k %d amp %f fun %f delta %f \n", iter, k, amp, fun, delta[k]);
           printf(" -----> valeur de k %d delta %f da1 %f da2 %f  \n", k, delta[k], da1[k], da2[k]);
         }
 
         chi2 = chi2 + delta[k] * delta[k];
 
         if (debug == 1) {
           printf(" CHECK chi2 %f deltachi2 %f sample %d iter %d \n", chi2, delta[k] * delta[k], k, iter);
         }
       }
 
       // End Loop on samples //
 
       double wk1wk2;
 
       // Start Loop on samples //
 
       for (int k1 = nborn_min; k1 < nborn_max + 1; k1++) {
         wk1wk2 = 1.;
         int k2 = k1;
 
         DA.coeff[0][0] = da1[k1] * wk1wk2;
         DA.coeff[1][0] = da2[k1] * wk1wk2;
         DAT.coeff[0][0] = da1[k2];
         DAT.coeff[0][1] = da2[k2];
         DB.coeff[0][0] = db1[k1] * wk1wk2;
         DB.coeff[1][0] = db2[k1] * wk1wk2;
         DBT.coeff[0][0] = db1[k2];
         DBT.coeff[0][1] = db2[k2];
 
         //  Compute derivative matrix : matrix b[2][2]
 
         produit_mat_int(DA, DAT, BK);
 
         //  Compute matrix c[2][2]
 
         produit_mat_int(DA, DBT, C);
 
         //  Compute matrix d[2][2]
 
         produit_mat_int(DB, DBT, D);
 
         //  Compute matrix y[3] and z[2] depending of delta (amp-fun)
 
         delta2 = delta[k2];
 
         somme_mat_int_scale(DA, YK, delta2);
         somme_mat_int_scale(DB, Z, delta2);
 
         ioktk[nk]++;
       }
 
       // End Loop on samples //
 
       //  Remove events with a bad shape
 
       if (ioktk[nk] < 4) {
         printf(" event rejected because npamp_used = %d \n", ioktk[nk]);
         continue;
       }
       chi2s = chi2 / (2. + (double)ns + 2.);
       chi2tot += chi2s;
 
       if (debug == 1) {
         if (nevt == 198 || nevt == 199) {
           std::cout << "adc123 pour l'evt " << nevt << " = " << adcval[nevt][nborn_min] << " = "
                     << adcval[nevt][imax[nevt]] << " = " << adcval[nevt][nborn_max] << std::endl;
           std::cout << "chi2s  pour l'evt " << nevt << " = " << chi2s << " " << chi2 << " " << ns << "  " << iter
                     << std::endl;
           std::cout << "chi2tot           " << nevt << " = " << chi2tot << "  " << iter << std::endl;
         }
       }
 
       //  Transpose matrix C ---> CT
 
       transpose_mat(C, CT);
 
       //  Calculate DM1 (inverse of D matrix 2x2)
 
       inverse_mat(D, DM1);
 
       //  Set matrix product c*d in memory in order to compute variations
       //   of parameters B at the end of the iteration loop
       //   the variations of parameters b are dependant of the variations of
       //   parameters da[1],da[2]
 
       cti[nk][0] = CT.coeff[0][0];
       cti[nk][1] = CT.coeff[0][1];
       cti[nk][2] = CT.coeff[1][0];
       cti[nk][3] = CT.coeff[1][1];
 
       dm1i[nk][0] = DM1.coeff[0][0];
       dm1i[nk][1] = DM1.coeff[0][1];
       dm1i[nk][2] = DM1.coeff[1][0];
       dm1i[nk][3] = DM1.coeff[1][1];
 
       zi[nk][0] = Z.coeff[0][0];
       zi[nk][1] = Z.coeff[1][0];
 
       //   Sum the matrix b and y after every event
 
       for (k = 0; k < numb_a; k++) {
         Y.coeff[k][0] += YK.coeff[k][0];
       }
       somme_mat_int(BK, B);
 
       //   Calculate c(d-1)
 
       produit_mat(C, DM1, CDM1);
 
       // Compute c(d-1)ct
 
       produit_mat_int(CDM1, CT, CDM1CT);
 
       // Compute c(d-1)z
 
       produit_mat_int(CDM1, Z, CDM1Z);
     }
     // End Loop on events //
 
     //  Compute b-cdm1ct
 
     diff_mat(B, CDM1CT, X);
     inverse_mat(X, XINV);
     diff_mat(Y, CDM1Z, RES2);
 
     // Calculation is now easy for da[0] da[1]
 
     produit_mat(XINV, RES2, A_CROISS);
 
     //  A la fin, on peut iterer en mesurant l'accroissement a apporter
     //    des parametres globaux par la formule db[i] = dm1(z-ct*da[i])
 
     for (k = 0; k < nk + 1; k++) {
       if (METHODE == 2) {
         ZMCT.coeff[0][0] = zi[k][0] - (cti[k][0] * A_CROISS.coeff[0][0] + cti[k][1] * A_CROISS.coeff[1][0]);
         ZMCT.coeff[1][0] = zi[k][1] - (cti[k][2] * A_CROISS.coeff[0][0] + cti[k][3] * A_CROISS.coeff[1][0]);
       }
 
       dbi[k][0] = dm1i[k][0] * ZMCT.coeff[0][0] + dm1i[k][1] * ZMCT.coeff[1][0];
       dbi[k][1] = dm1i[k][2] * ZMCT.coeff[0][0] + dm1i[k][3] * ZMCT.coeff[1][0];
       if (debug == 1) {
         if (k < 100) {
           printf(" variations de b1= %f et b2= %f  \n", dbi[k][0], dbi[k][1]);
         }
       }
       db_i[k][0] = bi[k][0] + dbi[k][0];
       db_i[k][1] = bi[k][1] + dbi[k][1];
     }
 
     //   dbi[0] et dbi[1] mesurent les variations a apporter aux
     //   parametres du signal
 
     a1 += A_CROISS.coeff[0][0];
     a2 += A_CROISS.coeff[1][0];
 
     if (debug == 1) {
       printf(" CHECK croiss coef0: %f  croiss coef1: %f iter %d \n",
              fabs(A_CROISS.coeff[0][0]),
              fabs(A_CROISS.coeff[1][0]),
              iter);
     }
     if (fabs(A_CROISS.coeff[0][0]) < 0.001 && fabs(A_CROISS.coeff[1][0]) < 0.001)
       break;
   }
 
   //  End Loop on iterations //
 
   parout[0] = a1;
   parout[1] = a2;
   parout[2] = a3;
   if (debug == 1) {
     printf(" resultats trouves au bout de %d iterations \n", iter);
     printf(" parametre a1 = %f \n", a1);
     printf(" parametre a2 = %f \n", a2);
   }
 
   if (debug == 1) {
     std::cout << " Final chi2 / NDOF  :  " << chi2tot / nevtmax << std::endl;
     std::cout << " Final (alpha,beta) : (" << a1 << "," << a2 << ")" << std::endl;
   }
 
   return chi2tot / nevtmax;
 }

double TFParams::inv3x3	(	double	a[3][3],
		double	b[3][3]
	)

Definition at line 957 of file TFParams.cc.

References mps_fire::i, dqmiolumiharvest::j, and gpuVertexFinder::printf().

                                                       {
   /*   a[ligne][colonne]   b[ligne][colonne]   */
   int i, j;
   double deter = 0.;
   b[0][0] = a[1][1] * a[2][2] - a[2][1] * a[1][2];
   b[1][1] = a[0][0] * a[2][2] - a[2][0] * a[0][2];
   b[2][2] = a[0][0] * a[1][1] - a[0][1] * a[1][0];
   printf("a[x][x] %e %e %e %e %e %e %e \n",
          a[0][0],
          a[1][1],
          a[0][1],
          a[1][0],
          a[0][0] * a[1][1],
          a[0][1] * a[1][0],
          b[2][2]);
   b[0][1] = a[2][1] * a[0][2] - a[0][1] * a[2][2];
   b[0][2] = a[0][1] * a[1][2] - a[1][1] * a[0][2];
   b[1][0] = a[1][2] * a[2][0] - a[1][0] * a[2][2];
   b[1][2] = a[1][0] * a[0][2] - a[0][0] * a[1][2];
   b[2][0] = a[1][0] * a[2][1] - a[1][1] * a[2][0];
   b[2][1] = a[0][1] * a[2][0] - a[0][0] * a[2][1];
   deter = a[0][0] * b[0][0] + a[1][0] * b[0][1] + a[2][0] * b[0][2];
   printf(" deter = %e \n", deter);
   for (i = 0; i < 3; i++) {
     for (j = 0; j < 3; j++) {
       printf(" avant division a[3][3] %d %d  %e \n", i, j, a[i][j]);
       printf(" avant division b[3][3] %d %d  %e %e \n", i, j, b[i][j], deter);
       b[i][j] = b[i][j] / deter;
       printf(" valeur de b[3][3] apres division %d %d  %e %e \n", i, j, b[i][j], deter);
     }
   }
   return deter;
 }

double TFParams::inverpj	(	int	n,
		double	g[dimmat][dimmat],
		double	ginv[dimmat][dimmat]
	)

Definition at line 894 of file TFParams.cc.

References cms::cuda::be, g, mps_fire::i, dqmiolumiharvest::j, findQualityFiles::jj, isotrackApplyRegressor::k, dqmiodumpmetadata::n, alignCSCRings::r, alignCSCRings::s, and mathSSE::sqrt().

                                                                                      {
   /*                                                                   */
   /*  inversion d une matrice symetrique definie positive de taille n  */
   /*  J.P. Pansart   Novembre 99                                       */
   /*                                                                   */
   int i, j, k, jj;
   double r, s;
   double deter = 0;
   double al[dimmat][dimmat], be[dimmat][dimmat];
   /*   initialisation                                                  */
   for (i = 0; i < n; i++) {
     for (j = 0; j < n; j++) {
       al[i][j] = 0.;
       be[i][j] = 0.;
     }
   }
   /*  decomposition en vecteurs sur une base orthonormee               */
   al[0][0] = sqrt(g[0][0]);
   for (i = 1; i < n; i++) {
     al[i][0] = g[0][i] / al[0][0];
     for (j = 1; j <= i; j++) {
       s = 0.;
       for (k = 0; k <= j - 1; k++) {
         s = s + al[i][k] * al[j][k];
       }
       r = g[i][j] - s;
       if (j < i)
         al[i][j] = r / al[j][j];
       if (j == i)
         al[i][j] = sqrt(r);
     }
   }
   /*  inversion de la matrice al                                       */
   be[0][0] = 1. / al[0][0];
   for (i = 1; i < n; i++) {
     be[i][i] = 1. / al[i][i];
     for (j = 0; j < i; j++) {
       jj = i - j - 1;
       s = 0.;
       for (k = jj + 1; k <= i; k++) {
         s = s + be[i][k] * al[k][jj];
       }
       be[i][jj] = -s / al[jj][jj];
     }
   }
   /*   calcul de la matrice ginv                                       */
   for (i = 0; i < n; i++) {
     for (j = 0; j < n; j++) {
       s = 0.;
       for (k = 0; k < n; k++) {
         s = s + be[k][i] * be[k][j];
       }
       ginv[i][j] = s;
       //    if (debug==1){
       //printf("valeur de la matrice %d %d %f \n",i,j,ginv[i][j]) ;
       //}
     }
   }
   return deter;
 }

void TFParams::inverse_mat	(	matrice	A,
		matrice	M
	)

Definition at line 719 of file TFParams.cc.

References matrice::coeff, mps_fire::i, dqmiolumiharvest::j, matrice::nb_colonnes, matrice::nb_lignes, and gpuVertexFinder::printf().

                                                {
   /*   A[ligne][colonne]   B[ligne][colonne]   */
   int i, j;
   double deter = 0.;
   /*  M est la matrice inverse de A */
 
   if (A.nb_lignes != A.nb_colonnes) {
     printf(" attention matrice non inversible !!!! %d lignes %d colonnes \n", A.nb_lignes, A.nb_colonnes);
     return;
   }
   zero_mat(M);
   if (A.nb_lignes == 2) {
     deter = A.coeff[0][0] * A.coeff[1][1] - A.coeff[0][1] * A.coeff[1][0];
     M.coeff[0][0] = A.coeff[1][1] / deter;
     M.coeff[0][1] = -A.coeff[0][1] / deter;
     M.coeff[1][0] = -A.coeff[1][0] / deter;
     M.coeff[1][1] = A.coeff[0][0] / deter;
   } else if (A.nb_lignes == 3) {
     M.coeff[0][0] = A.coeff[1][1] * A.coeff[2][2] - A.coeff[2][1] * A.coeff[1][2];
     M.coeff[1][1] = A.coeff[0][0] * A.coeff[2][2] - A.coeff[2][0] * A.coeff[0][2];
 
     M.coeff[2][2] = A.coeff[0][0] * A.coeff[1][1] - A.coeff[0][1] * A.coeff[1][0];
     M.coeff[0][1] = A.coeff[2][1] * A.coeff[0][2] - A.coeff[0][1] * A.coeff[2][2];
     M.coeff[0][2] = A.coeff[0][1] * A.coeff[1][2] - A.coeff[1][1] * A.coeff[0][2];
     M.coeff[1][0] = A.coeff[1][2] * A.coeff[2][0] - A.coeff[1][0] * A.coeff[2][2];
     M.coeff[1][2] = A.coeff[1][0] * A.coeff[0][2] - A.coeff[0][0] * A.coeff[1][2];
     M.coeff[2][0] = A.coeff[1][0] * A.coeff[2][1] - A.coeff[1][1] * A.coeff[2][0];
     M.coeff[2][1] = A.coeff[0][1] * A.coeff[2][0] - A.coeff[0][0] * A.coeff[2][1];
     deter = A.coeff[0][0] * M.coeff[0][0] + A.coeff[1][0] * M.coeff[0][1] + A.coeff[2][0] * M.coeff[0][2];
     for (i = 0; i < 3; i++) {
       for (j = 0; j < 3; j++)
         M.coeff[i][j] = M.coeff[i][j] / deter;
     }
   } else {
     printf(" Attention , on ne peut inverser la MATRICE %d \n", A.nb_lignes);
     return;
   }
 
   return;
 }

double TFParams::lastShape	(	Double_t *	x,
		Double_t *	par
	)

Definition at line 1026 of file TFParams.cc.

References alpha, b1, b2, HLT_FULL_cff::beta, dt, funct::exp(), and HLT_FULL_cff::exponent.

                                                      {
   Double_t fitfun;
   Double_t alpha, beta;
   Double_t dt, alphadt, exponent;
   Double_t b1, b2;
   b1 = par[0];
   b2 = par[1];
   alpha = par[2];
   beta = par[3];
   dt = x[0] - b2;
   alphadt = alpha * dt;
   exponent = -(alphadt + (exp(-alphadt) - 1.)) / beta;
   fitfun = b1 * exp(exponent);
   return fitfun;
 }

double TFParams::lastShape2	(	Double_t *	x,
		Double_t *	par
	)

Definition at line 1041 of file TFParams.cc.

References alpha, b1, b2, HLT_FULL_cff::beta, dt, funct::exp(), and HLT_FULL_cff::exponent.

                                                       {
   Double_t fitfun;
   Double_t alpha, beta;
   Double_t dt, expo1, dt2, exponent;
   Double_t b1, b2;
   b1 = par[0];
   b2 = par[1];
   alpha = par[2];
   beta = par[3];
   dt = x[0] - b2;
   expo1 = exp(-beta * dt);
   dt2 = dt * dt;
   exponent = -(alpha * dt2 + (expo1 - 1.));
   fitfun = b1 * exp(exponent);
   return fitfun;
 }

double TFParams::mixShape	(	Double_t *	x,
		Double_t *	par
	)

Definition at line 1128 of file TFParams.cc.

References alpha, b1, b2, HLT_FULL_cff::beta, dt, funct::exp(), HLT_FULL_cff::exponent, fact, funct::pow(), and submitPVValidationJobs::t.

                                                     {
   Double_t fitval0, fitval;
   Double_t alpha, beta, fact, puiss;
   Double_t dt, alpha2dt, exponent;
   Double_t b1, b2, alpha2, t;
   b1 = par[0];
   b2 = par[1];
   alpha = par[2];
   alpha2 = par[3];
   beta = par[4];
   //
   t = x[0];
   dt = x[0] - b2;
   //
   if (t > 0.) {
     fact = t / b2;
     puiss = pow(fact, alpha);
     fitval0 = puiss * exp(-alpha * dt / b2);
   } else {
     fitval0 = 1.;
   }
   dt = x[0] - b2;
   alpha2dt = dt * alpha2;
   exponent = -(alpha2dt + (exp(-alpha2dt) - 1.)) / beta;
   fitval = b1 * fitval0 * exp(exponent);
   return fitval;
 }

double TFParams::parab	(	double *	,
		Int_t	,
		Int_t	,
		double *
	)

Definition at line 1091 of file TFParams.cc.

References makePileupJSON::denom, dt, and isotrackApplyRegressor::k.

                                                                                        {
   /* Now we calculate the parabolic adjustement in order to get        */
   /*    maximum and time max                                           */
 
   double denom, dt, amp1, amp2, amp3;
   double ampmax = 0.;
   int imax = 0;
   int k;
   /*
                                                                    */
   for (k = nmin; k < nmax; k++) {
     if (ampl[k] > ampmax) {
       ampmax = ampl[k];
       imax = k;
     }
   }
   amp1 = ampl[imax - 1];
   amp2 = ampl[imax];
   amp3 = ampl[imax + 1];
   denom = 2. * amp2 - amp1 - amp3;
   /*                                         */
   if (denom > 0.) {
     dt = 0.5 * (amp3 - amp1) / denom;
   } else {
     //printf("denom =%f\n",denom)  ;
     dt = 0.5;
   }
   /*                                             */
   /* ampmax correspond au maximum d'amplitude parabolique et dt        */
   /* decalage en temps par rapport au sample maximum soit k + dt       */
 
   parout[0] = amp2 + (amp3 - amp1) * dt * 0.25;
   parout[1] = (double)imax + dt;
   parout[2] = (double)imax;
   return denom;
 }

Double_t TFParams::polfit	(	Int_t	ns,
		Int_t	imax,
		Double_t	par3d[dimout],
		Double_t	errpj[dimmat][dimmat],
		double *	adcpj
	)

Definition at line 759 of file TFParams.cc.

References h, mps_fire::i, and hgcalPerformanceValidation::val.

                                                                                                                      {
   double val, val2, val3, adfmx[dimmat], parfp3[dimout];
   double ius[dimmat], maskp3[dimmat];
   double deglib, fit3, tm, h, xki2;
   int i, nus, ilow, isup;
   val = adcpj[imax];
   val2 = val / 2.;
   val3 = val / 3.;
   ilow = 0;
   isup = ns;
   deglib = -4.;
   for (i = 0; i < ns; i++) {
     deglib = deglib + 1.;
     ius[i] = 1.;
     if ((adcpj[i] < val3) && (i < imax)) {
       ilow = i;
     }
     if (adcpj[i] > val2) {
       isup = i;
     }
   }
   ilow = ilow + 1;
   if (ilow == imax)
     ilow = ilow - 1;
   if (isup - ilow < 3)
     isup = ilow + 3;
   nus = 0;
   for (i = ilow; i <= isup; i++) {
     adfmx[nus] = adcpj[i];
     maskp3[nus] = 0.;
     if (ius[i] == 1) {
       maskp3[nus] = 1.;
       nus = nus + 1;
     }
   }
   if (nus < 4)
     return 10000.;
   xki2 = f3deg(nus, parfp3, maskp3, adfmx, errpj);
   tm = parfp3[4];
   h = parfp3[5];
   tm = tm + (double)ilow;
   par3d[0] = h;
   par3d[1] = tm;
   fit3 = xki2;
   return fit3;
 }

void TFParams::print_mat ( matrice M )

Definition at line 681 of file TFParams.cc.

References matrice::coeff, mps_fire::i, dqmiolumiharvest::j, matrice::nb_colonnes, matrice::nb_lignes, and gpuVertexFinder::printf().

                                   {
   int i, j;
   if (M.coeff == nullptr) {
     printf(" erreur : affichage d'une matrice vide \n");
     return;
   }
   printf(" m_nli %d M_ncol %d \n", M.nb_lignes, M.nb_colonnes);
   for (i = 0; i < M.nb_lignes; i++) {
     for (j = 0; j < M.nb_colonnes; j++)
       printf(" MATRICE i= %d j= %d ---> %e \n", i, j, M.coeff[i][j]);
   }
   //printf(" apres passage d'impression \n") ;
   return;
 }

void TFParams::print_mat_nk	(	matrice	M,
		int	nk
	)

Definition at line 709 of file TFParams.cc.

References matrice::coeff, dqmiolumiharvest::j, matrice::nb_colonnes, matrice::nb_lignes, and gpuVertexFinder::printf().

                                              {
   int j;
   if (M.coeff == nullptr)
     printf(" erreur : affichage d'une matrice vide \n");
   printf(" nk = %d m_nli %d M_ncol %d \n", nk, M.nb_lignes, M.nb_colonnes);
   for (j = 0; j < M.nb_colonnes; j++)
     printf(" MATRICE nk= %d j= %d  ---> %e \n", nk, j, M.coeff[nk][j]);
   printf(" apres passage d'impression \n");
   return;
 }

void TFParams::produit_mat	(	matrice	A,
		matrice	B,
		matrice	M
	)

Definition at line 523 of file TFParams.cc.

References matrice::coeff, mps_fire::i, dqmiolumiharvest::j, isotrackApplyRegressor::k, matrice::nb_colonnes, matrice::nb_lignes, and gpuVertexFinder::printf().

                                                           {
   int i, j, k;
   //  resultat du produit A*B = M
   if (A.nb_colonnes != B.nb_lignes) {
     printf(" Erreur : produit de matrices de tailles incompatibles \n ");
     M.coeff = nullptr;
     return;
   }
   M.nb_lignes = A.nb_lignes;
   M.nb_colonnes = B.nb_colonnes;
   zero_mat(M);
   for (i = 0; i < M.nb_lignes; i++) {
     for (j = 0; j < M.nb_colonnes; j++) {
       for (k = 0; k < A.nb_colonnes; k++) {
         M.coeff[i][j] += A.coeff[i][k] * B.coeff[k][j];
       }
     }
   }
   return;
 }

void TFParams::produit_mat_int	(	matrice	A,
		matrice	B,
		matrice	M
	)

Definition at line 544 of file TFParams.cc.

References matrice::coeff, mps_fire::i, dqmiolumiharvest::j, isotrackApplyRegressor::k, matrice::nb_colonnes, matrice::nb_lignes, and gpuVertexFinder::printf().

                                                               {
   int i, j, k;
   if (A.nb_colonnes != B.nb_lignes) {
     printf(" Erreur : produit de matrices de tailles incompatibles \n ");
     M.coeff = nullptr;
     return;
   }
   M.nb_lignes = A.nb_lignes;
   M.nb_colonnes = B.nb_colonnes;
   for (i = 0; i < M.nb_lignes; i++) {
     for (j = 0; j < M.nb_colonnes; j++) {
       for (k = 0; k < A.nb_colonnes; k++) {
         M.coeff[i][j] += A.coeff[i][k] * B.coeff[k][j];
       }
     }
   }
   return;
 }

double TFParams::pulseShapepj	(	Double_t *	x,
		Double_t *	par
	)

Definition at line 991 of file TFParams.cc.

References isotrackTrainRegressor::a1, isotrackTrainRegressor::a2, alpha, b1, b2, HLT_FULL_cff::beta, dt, funct::exp(), h, and funct::pow().

                                                         {
   Double_t fitfun;
   Double_t ped, h, tm, alpha, beta;
   Double_t dt, dtsbeta, albet, variab, puiss;
   Double_t b1, b2, a1, a2;
   b1 = par[0];
   b2 = par[1];
   a1 = par[2];
   a2 = par[3];
 
   ped = 0.;
   h = b1;
   tm = b2;
   alpha = a1;
   beta = a2;
   dt = x[0] - tm;
   //printf(" par %f %f %f %f dt = %f albet = %f",b1,b2,a1,a2,dt,albet) ;
   albet = alpha * beta;
   if (albet <= 0)
     return ((Double_t)0.);
 
   if (dt > -albet) {
     dtsbeta = dt / beta;
     variab = 1. + dt / albet;
     puiss = pow(variab, alpha);
     fitfun = h * puiss * exp(-dtsbeta) + ped;
     //printf(" dt = %f h = %f puiss = %f exp(-dtsbeta) %f \n",dt,h,puiss,
     // exp(-dtsbeta)) ;
   } else {
     fitfun = ped;
   }
 
   return fitfun;
 }

Double_t TFParams::pulseShapepj2	(	Double_t *	x,
		Double_t *	par
	)

Definition at line 1058 of file TFParams.cc.

References isotrackTrainRegressor::a1, isotrackTrainRegressor::a2, alpha, b1, HLT_FULL_cff::beta, dt, funct::exp(), h, and funct::pow().

                                                            {
   Double_t fitfun;
   Double_t ped, h, /*tm,*/ alpha, beta;
   Double_t dt, dtsbeta, albet, variab, puiss;
   Double_t b1, /*b2,*/ a1, a2;
   b1 = par[0];
   //b2 = par[1] ;
   a1 = par[2];
   a2 = par[3];
   ped = 0.;
   h = b1;
   //tm    =  b2 ;
   alpha = a1;
   beta = a2;
   dt = x[0];
   albet = alpha * beta;
   if (albet <= 0)
     return ((Double_t)0.);
 
   if (dt > -albet) {
     dtsbeta = dt / beta;
     variab = 1. + dt / albet;
     puiss = pow(variab, alpha);
     fitfun = h * puiss * exp(-dtsbeta) + ped;
   } else {
     fitfun = ped;
   }
 
   /*  printf( "fitfun %f %f %f %f, %f %f %f\n", ped, h, tm, alpha, beta, *x, fitfun );  */
 
   return fitfun;
 }

void TFParams::set_const	(	int	n_samples,
		int	sample_min,
		int	sample_max,
		double	alpha,
		double	beta,
		int	nevtmaximum
	)

Definition at line 509 of file TFParams.cc.

References alpha, HLT_FULL_cff::beta, and gpuVertexFinder::printf().

Referenced by TShapeAnalysis::computeShape().

                                                                                                                   {
   /*------------------------------------------------------------------------*/
   ns = n_samples;
   nsmin = sample_min;
   nsmax = sample_max;
   nevtmax = nevtmaximum;
   a1ini = alpha;
   a2ini = 0.0;
   a3ini = beta;
   step_shape = .04;
   METHODE = 2;
   if (ns > SDIM2)
     printf("warning: NbOfsamples exceed maximum\n");
 }

void TFParams::somme_mat_int	(	matrice	A,
		matrice	M
	)

Definition at line 594 of file TFParams.cc.

References matrice::coeff, mps_fire::i, dqmiolumiharvest::j, matrice::nb_colonnes, matrice::nb_lignes, and gpuVertexFinder::printf().

                                                  {
   int i, j;
   /* resultat de la somme integree M += A */
   if (A.nb_lignes != M.nb_lignes) {
     printf(" Erreur : somme de matrices de tailles incompatibles \n ");
     M.coeff = nullptr;
     return;
   }
   M.nb_lignes = A.nb_lignes;
   M.nb_colonnes = A.nb_colonnes;
   for (i = 0; i < M.nb_lignes; i++) {
     for (j = 0; j < M.nb_colonnes; j++)
       M.coeff[i][j] += A.coeff[i][j];
   }
   return;
 }

void TFParams::somme_mat_int_scale	(	matrice	A,
		matrice	M,
		double	delta
	)

Definition at line 610 of file TFParams.cc.

References matrice::coeff, mps_fire::i, dqmiolumiharvest::j, matrice::nb_colonnes, and matrice::nb_lignes.

                                                                      {
   int i, j;
   M.nb_lignes = A.nb_lignes;
   M.nb_colonnes = A.nb_colonnes;
   for (i = 0; i < M.nb_lignes; i++) {
     for (j = 0; j < M.nb_colonnes; j++)
       M.coeff[i][j] += A.coeff[i][j] * delta;
   }
   return;
 }

void TFParams::transpose_mat	(	matrice	A,
		matrice	M
	)

Definition at line 620 of file TFParams.cc.

References matrice::coeff, mps_fire::i, dqmiolumiharvest::j, matrice::nb_colonnes, and matrice::nb_lignes.

                                                  {
   int i, j;
   // resultat de la transposition = matrice M
   for (i = 0; i < A.nb_lignes; i++) {
     for (j = 0; j < A.nb_colonnes; j++) {
       M.coeff[j][i] = A.coeff[i][j];
     }
   }
   return;
 }

void TFParams::zero_mat ( matrice M )

Definition at line 695 of file TFParams.cc.

References matrice::coeff, mps_fire::i, dqmiolumiharvest::j, matrice::nb_colonnes, and matrice::nb_lignes.

                                  {
   int i, j;
   for (i = 0; i < M.nb_lignes; i++) {
     for (j = 0; j < M.nb_colonnes; j++)
       M.coeff[i][j] = 0.;
   }
   return;
 }

void TFParams::zero_mat_nk	(	matrice	M,
		int	nk
	)

Definition at line 703 of file TFParams.cc.

References matrice::coeff, dqmiolumiharvest::j, and matrice::nb_colonnes.

                                             {
   int j;
   for (j = 0; j < M.nb_colonnes; j++)
     M.coeff[nk][j] = 0.;
   return;
 }

Member Data Documentation

double TFParams::a1ini

private

Definition at line 51 of file TFParams.h.

double TFParams::a2ini

private

Definition at line 52 of file TFParams.h.

double TFParams::a3ini

private

Definition at line 53 of file TFParams.h.

double TFParams::adclu[26]

private

Definition at line 55 of file TFParams.h.

constexpr unsigned int TFParams::dimmat = 30

static

Definition at line 40 of file TFParams.h.

constexpr unsigned int TFParams::dimout = 10

static

Definition at line 41 of file TFParams.h.

int TFParams::METHODE

private

Definition at line 57 of file TFParams.h.

char TFParams::name_mat[10]

Definition at line 76 of file TFParams.h.

constexpr unsigned int TFParams::nbmax_cell = 1000

static

Definition at line 42 of file TFParams.h.

int TFParams::nevtmax

private

Definition at line 50 of file TFParams.h.

int TFParams::ns

private

Definition at line 47 of file TFParams.h.

int TFParams::nsmax

private

Definition at line 49 of file TFParams.h.

int TFParams::nsmin

private

Definition at line 48 of file TFParams.h.

constexpr int TFParams::PLSHDIM = 650

static

Definition at line 44 of file TFParams.h.

constexpr int TFParams::SDIM2 = 10

static

Definition at line 43 of file TFParams.h.

double TFParams::step_shape

private

Definition at line 54 of file TFParams.h.

double TFParams::weight_matrix[10][10]

private

Definition at line 56 of file TFParams.h.

Public Member Functions

Public Attributes

Static Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation