#include <TMultiDimFet.h>

Inheritance diagram for TMultiDimFet:

Public Types
enum	EMDFPolyType { kMonomials, kChebyshev, kLegendre }

Public Member Functions
virtual void	AddRow (const Double_t *x, Double_t D, Double_t E=0)

virtual void	AddTestRow (const Double_t *x, Double_t D, Double_t E=0)

void	Clear (Option_t *option="") override

virtual Double_t	Eval (const Double_t x, const Double_t coeff=nullptr) const

virtual void	FindParameterization (double precision)

Double_t	GetChi2 () const

const TVectorD *	GetCoefficients () const

const TMatrixD *	GetCorrelationMatrix () const

Double_t	GetError () const

std::vector< Int_t >	GetFunctionCodes () const

const TMatrixD *	GetFunctions () const

virtual TList *	GetHistograms () const

Double_t	GetMaxAngle () const

Int_t	GetMaxFunctions () const

std::vector< Int_t >	GetMaxPowers () const

Double_t	GetMaxQuantity () const

Int_t	GetMaxStudy () const

Int_t	GetMaxTerms () const

const TVectorD *	GetMaxVariables () const

Double_t	GetMeanQuantity () const

const TVectorD *	GetMeanVariables () const

Double_t	GetMinAngle () const

Double_t	GetMinQuantity () const

Double_t	GetMinRelativeError () const

const TVectorD *	GetMinVariables () const

Int_t	GetNCoefficients () const

Int_t	GetNVariables () const

Int_t	GetPolyType () const

std::vector< Int_t >	GetPowerIndex () const

Double_t	GetPowerLimit () const

std::vector< Int_t >	GetPowers () const

Double_t	GetPrecision () const

const TVectorD *	GetQuantity () const

Double_t	GetResidualMax () const

Int_t	GetResidualMaxRow () const

Double_t	GetResidualMin () const

Int_t	GetResidualMinRow () const

Double_t	GetResidualSumSq () const

Double_t	GetRMS () const

Int_t	GetSampleSize () const

const TVectorD *	GetSqError () const

Double_t	GetSumSqAvgQuantity () const

Double_t	GetSumSqQuantity () const

Double_t	GetTestError () const

Double_t	GetTestPrecision () const

const TVectorD *	GetTestQuantity () const

Int_t	GetTestSampleSize () const

const TVectorD *	GetTestSqError () const

const TVectorD *	GetTestVariables () const

const TVectorD *	GetVariables () const

Bool_t	IsFolder () const override

virtual Double_t	MakeChi2 (const Double_t *coeff=nullptr)

virtual void	MakeCode (const char functionName="MDF", Option_t option="")

virtual void	MakeHistograms (Option_t *option="A")

virtual void	MakeMethod (const Char_t className="MDF", Option_t option="")

const TMultiDimFet &	operator= (const TMultiDimFet &in)

void	Print (Option_t *option="ps") const override

virtual void	PrintPolynomialsSpecial (Option_t *option="m") const

void	ReducePolynomial (double error)

void	SetMaxAngle (Double_t angle=0)

void	SetMaxFunctions (Int_t n)

void	SetMaxPowers (const Int_t *powers)

void	SetMaxStudy (Int_t n)

void	SetMaxTerms (Int_t terms)

void	SetMinAngle (Double_t angle=1)

void	SetMinRelativeError (Double_t error)

void	SetPowerLimit (Double_t limit=1e-3)

virtual void	SetPowers (const Int_t *powers, Int_t terms)

	TMultiDimFet ()

	TMultiDimFet (Int_t dimension, EMDFPolyType type=kMonomials, Option_t *option="")

void	ZeroDoubiousCoefficients (double error)

	~TMultiDimFet () override

Protected Member Functions
virtual Double_t	EvalControl (const Int_t *powers)

virtual Double_t	EvalFactor (Int_t p, Double_t x) const

virtual void	MakeCandidates ()

virtual void	MakeCoefficientErrors ()

virtual void	MakeCoefficients ()

virtual void	MakeCorrelation ()

virtual Double_t	MakeGramSchmidt (Int_t function)

virtual void	MakeNormalized ()

virtual void	MakeParameterization ()

virtual void	MakeRealCode (const char filename, const char classname, Option_t *option="")

virtual Bool_t	Select (const Int_t *iv)

virtual Bool_t	TestFunction (Double_t squareResidual, Double_t dResidur)

Protected Attributes
Double_t	fChi2
	Root mean square of fit. More...

TVectorD	fCoefficients
	Model matrix. More...

TVectorD	fCoefficientsRMS

Double_t	fCorrelationCoeff
	Relative precision of test. More...

TMatrixD	fCorrelationMatrix
	Multi Correlation coefficient. More...

Double_t	fError
	Exit code of parameterisation. More...

std::vector< Int_t >	fFunctionCodes

TMatrixD	fFunctions
	Control parameter. More...

Byte_t	fHistogramMask
	List of histograms. More...

TList *	fHistograms
	Multi Correlation coefficient. More...

Bool_t	fIsUserFunction

Bool_t	fIsVerbose

Double_t	fMaxAngle
	Min angle for acepting new function. More...

Int_t	fMaxFunctions
	Functions evaluated over sample. More...

Int_t	fMaxFunctionsTimesNVariables
	maximum powers from fit, ex-array More...

std::vector< Int_t >	fMaxPowers
	Min relative error accepted. More...

std::vector< Int_t >	fMaxPowersFinal
	Norm of the evaluated functions. More...

Double_t	fMaxQuantity

Double_t	fMaxResidual
	Vector of the final residuals. More...

Int_t	fMaxResidualRow
	Min redsidual value. More...

Int_t	fMaxStudy
	acceptance code, ex-array More...

Int_t	fMaxTerms
	Max angle for acepting new function. More...

TVectorD	fMaxVariables
	mean value of independent variables More...

Double_t	fMeanQuantity
	Training sample, error in quantity. More...

TVectorD	fMeanVariables

Double_t	fMinAngle
	Size of test sample. More...

Double_t	fMinQuantity
	Max value of dependent quantity. More...

Double_t	fMinRelativeError

Double_t	fMinResidual
	Max redsidual value. More...

Int_t	fMinResidualRow
	Row giving max residual. More...

TVectorD	fMinVariables

Int_t	fNCoefficients
	Sum of Square residuals. More...

Int_t	fNVariables
	Training sample, independent variables. More...

TVectorD	fOrthCoefficients

TMatrixD	fOrthCurvatureMatrix
	The model coefficients. More...

TVectorD	fOrthFunctionNorms
	As above, but orthogonalised. More...

TMatrixD	fOrthFunctions
	max functions to study More...

Int_t	fParameterisationCode
	Chi square of fit. More...

EMDFPolyType	fPolyType
	Bit pattern of hisograms used. More...

std::vector< Int_t >	fPowerIndex

Double_t	fPowerLimit
	maximum powers, ex-array More...

std::vector< Int_t >	fPowers

Double_t	fPrecision
	Error from test. More...

TVectorD	fQuantity

TVectorD	fResiduals

Double_t	fRMS
	Vector of RMS of coefficients. More...

Int_t	fSampleSize

Bool_t	fShowCorrelation

TVectorD	fSqError
	Training sample, dependent quantity. More...

Double_t	fSumSqAvgQuantity
	SumSquare of dependent quantity. More...

Double_t	fSumSqQuantity
	Min value of dependent quantity. More...

Double_t	fSumSqResidual
	Row giving min residual. More...

Double_t	fTestCorrelationCoeff
	Correlation matrix. More...

Double_t	fTestError
	Error from parameterization. More...

Double_t	fTestPrecision
	Relative precision of param. More...

TVectorD	fTestQuantity
	Size of training sample. More...

Int_t	fTestSampleSize
	Test sample, independent variables. More...

TVectorD	fTestSqError
	Test sample, dependent quantity. More...

TVectorD	fTestVariables
	Test sample, Error in quantity. More...

TVectorD	fVariables
	Sum of squares away from mean. More...

Detailed Description

Definition at line 35 of file TMultiDimFet.h.

Member Enumeration Documentation

◆ EMDFPolyType

enum TMultiDimFet::EMDFPolyType

Enumerator
kMonomials
kChebyshev
kLegendre

Definition at line 46 of file TMultiDimFet.h.

Constructor & Destructor Documentation

◆ TMultiDimFet() [1/2]

TMultiDimFet::TMultiDimFet ( )

Definition at line 50 of file TMultiDimFet.cc.

                            {
   // Empty CTOR. Do not use
   fMeanQuantity = 0;
   fMaxQuantity = 0;
   fMinQuantity = 0;
   fSumSqQuantity = 0;
   fSumSqAvgQuantity = 0;
   fPowerLimit = 1;
  
   fMaxAngle = 0;
   fMinAngle = 1;
  
   fNVariables = 0;
   fMaxVariables = 0;
   fMinVariables = 0;
   fSampleSize = 0;
  
   fMaxAngle = 0;
   fMinAngle = 0;
  
   fPolyType = kMonomials;
   fShowCorrelation = kFALSE;
  
   fIsUserFunction = kFALSE;
  
   fHistograms = nullptr;
   fHistogramMask = 0;
  
   //fFitter                  = nullptr;
   //fgInstance               = nullptr;

References fHistogramMask, fHistograms, fIsUserFunction, fMaxAngle, fMaxQuantity, fMaxVariables, fMeanQuantity, fMinAngle, fMinQuantity, fMinVariables, fNVariables, fPolyType, fPowerLimit, fSampleSize, fShowCorrelation, fSumSqAvgQuantity, fSumSqQuantity, and kMonomials.

◆ TMultiDimFet() [2/2]

TMultiDimFet::TMultiDimFet	(	Int_t	dimension,
		EMDFPolyType	type = `kMonomials`,
		Option_t *	option = `""`
	)

Definition at line 158 of file TMultiDimFet.cc.

     : TNamed("multidimfit", "Multi-dimensional fit object"),
       fQuantity(dimension),
       fSqError(dimension),
       fVariables(dimension * 100),
       fMeanVariables(dimension),
       fMaxVariables(dimension),
       fMinVariables(dimension) {
   // Constructor
   // Second argument is the type of polynomials to use in
   // parameterisation, one of:
   //      TMultiDimFet::kMonomials
   //      TMultiDimFet::kChebyshev
   //      TMultiDimFet::kLegendre
   //
   // Options:
   //   K      Compute (k)correlation matrix
   //   V      Be verbose
   //
   // Default is no options.
   //
  
   //fgInstance = this;
  
   fMeanQuantity = 0;
   fMaxQuantity = 0;
   fMinQuantity = 0;
   fSumSqQuantity = 0;
   fSumSqAvgQuantity = 0;
   fPowerLimit = 1;
  
   fMaxAngle = 0;
   fMinAngle = 1;
  
   fNVariables = dimension;
   fMaxVariables = 0;
   fMaxFunctionsTimesNVariables = fMaxFunctions * fNVariables;
   fMinVariables = 0;
   fSampleSize = 0;
   fTestSampleSize = 0;
   fMinRelativeError = 0.01;
   fError = 0;
   fTestError = 0;
   fPrecision = 0;
   fTestPrecision = 0;
   fParameterisationCode = 0;
  
   fPolyType = type;
   fShowCorrelation = kFALSE;
   fIsVerbose = kFALSE;
  
   TString opt = option;
   opt.ToLower();
  
   if (opt.Contains("k"))
     fShowCorrelation = kTRUE;
   if (opt.Contains("v"))
     fIsVerbose = kTRUE;
  
   fIsUserFunction = kFALSE;
  
   fHistograms = nullptr;
   fHistogramMask = 0;
  
   fMaxPowers.resize(dimension);
   fMaxPowersFinal.resize(dimension);
   //fFitter                 = nullptr;

References pat::helper::ParametrizationHelper::dimension(), fError, fHistogramMask, fHistograms, fIsUserFunction, fIsVerbose, fMaxAngle, fMaxFunctions, fMaxFunctionsTimesNVariables, fMaxPowers, fMaxPowersFinal, fMaxQuantity, fMaxVariables, fMeanQuantity, fMinAngle, fMinQuantity, fMinRelativeError, fMinVariables, fNVariables, fParameterisationCode, fPolyType, fPowerLimit, fPrecision, fSampleSize, fShowCorrelation, fSumSqAvgQuantity, fSumSqQuantity, fTestError, fTestPrecision, fTestSampleSize, runTheMatrix::opt, and fileinputsource_cfi::option.

◆ ~TMultiDimFet()

TMultiDimFet::~TMultiDimFet ( )

override

Definition at line 228 of file TMultiDimFet.cc.

                             {
   if (fHistograms)
     fHistograms->Clear("nodelete");
   delete fHistograms;

References fHistograms.

Member Function Documentation

◆ AddRow()

void TMultiDimFet::AddRow	(	const Double_t *	x,
		Double_t	D,
		Double_t	E = `0`
	)

virtual

Definition at line 235 of file TMultiDimFet.cc.

                                                                    {
   // Add a row consisting of fNVariables independent variables, the
   // known, dependent quantity, and optionally, the square error in
   // the dependent quantity, to the training sample to be used for the
   // parameterization.
   // The mean of the variables and quantity is calculated on the fly,
   // as outlined in TPrincipal::AddRow.
   // This sample should be representive of the problem at hand.
   // Please note, that if no error is given Poisson statistics is
   // assumed and the square error is set to the value of dependent
   // quantity.  See also the
   // Begin_Html<a href="#TMultiDimFet:description">class description</a>End_Html
   if (!x)
     return;
  
   if (++fSampleSize == 1) {
     fMeanQuantity = D;
     fMaxQuantity = D;
     fMinQuantity = D;
   } else {
     fMeanQuantity *= 1 - 1. / Double_t(fSampleSize);
     fMeanQuantity += D / Double_t(fSampleSize);
     fSumSqQuantity += D * D;
  
     if (D >= fMaxQuantity)
       fMaxQuantity = D;
     if (D <= fMinQuantity)
       fMinQuantity = D;
   }
  
   // If the vector isn't big enough to hold the new data, then
   // expand the vector by half it's size.
   Int_t size = fQuantity.GetNrows();
   if (fSampleSize > size) {
     fQuantity.ResizeTo(size + size / 2);
     fSqError.ResizeTo(size + size / 2);
   }
  
   // Store the value
   fQuantity(fSampleSize - 1) = D;
   fSqError(fSampleSize - 1) = (E == 0 ? D : E);
  
   // Store data point in internal vector
   // If the vector isn't big enough to hold the new data, then
   // expand the vector by half it's size
   size = fVariables.GetNrows();
   if (fSampleSize * fNVariables > size)
     fVariables.ResizeTo(size + size / 2);
  
   // Increment the data point counter
   Int_t i, j;
   for (i = 0; i < fNVariables; i++) {
     if (fSampleSize == 1) {
       fMeanVariables(i) = x[i];
       fMaxVariables(i) = x[i];
       fMinVariables(i) = x[i];
     } else {
       fMeanVariables(i) *= 1 - 1. / Double_t(fSampleSize);
       fMeanVariables(i) += x[i] / Double_t(fSampleSize);
  
       // Update the maximum value for this component
       if (x[i] >= fMaxVariables(i))
         fMaxVariables(i) = x[i];
  
       // Update the minimum value for this component
       if (x[i] <= fMinVariables(i))
         fMinVariables(i) = x[i];
     }
  
     // Store the data.
     j = (fSampleSize - 1) * fNVariables + i;
     fVariables(j) = x[i];
   }

References fMaxQuantity, fMaxVariables, fMeanQuantity, fMeanVariables, fMinQuantity, fMinVariables, fNVariables, fQuantity, fSampleSize, fSqError, fSumSqQuantity, fVariables, mps_fire::i, dqmiolumiharvest::j, findQualityFiles::size, and x.

Referenced by LHCOpticsApproximator::Train().

◆ AddTestRow()

void TMultiDimFet::AddTestRow	(	const Double_t *	x,
		Double_t	D,
		Double_t	E = `0`
	)

virtual

Definition at line 311 of file TMultiDimFet.cc.

                                                                        {
   // Add a row consisting of fNVariables independent variables, the
   // known, dependent quantity, and optionally, the square error in
   // the dependent quantity, to the test sample to be used for the
   // test of the parameterization.
   // This sample needn't be representive of the problem at hand.
   // Please note, that if no error is given Poisson statistics is
   // assumed and the square error is set to the value of dependent
   // quantity.  See also the
   // Begin_Html<a href="#TMultiDimFet:description">class description</a>End_Html
   if (fTestSampleSize++ == 0) {
     fTestQuantity.ResizeTo(fNVariables);
     fTestSqError.ResizeTo(fNVariables);
     fTestVariables.ResizeTo(fNVariables * 100);
   }
  
   // If the vector isn't big enough to hold the new data, then
   // expand the vector by half it's size.
   Int_t size = fTestQuantity.GetNrows();
   if (fTestSampleSize > size) {
     fTestQuantity.ResizeTo(size + size / 2);
     fTestSqError.ResizeTo(size + size / 2);
   }
  
   // Store the value
   fTestQuantity(fTestSampleSize - 1) = D;
   fTestSqError(fTestSampleSize - 1) = (E == 0 ? D : E);
  
   // Store data point in internal vector
   // If the vector isn't big enough to hold the new data, then
   // expand the vector by half it's size
   size = fTestVariables.GetNrows();
   if (fTestSampleSize * fNVariables > size)
     fTestVariables.ResizeTo(size + size / 2);
  
   // Increment the data point counter
   Int_t i, j;
   for (i = 0; i < fNVariables; i++) {
     j = fNVariables * (fTestSampleSize - 1) + i;
     fTestVariables(j) = x[i];
  
     if (x[i] > fMaxVariables(i))
       Warning("AddTestRow", "variable %d (row: %d) too large: %f > %f", i, fTestSampleSize, x[i], fMaxVariables(i));
     if (x[i] < fMinVariables(i))
       Warning("AddTestRow", "variable %d (row: %d) too small: %f < %f", i, fTestSampleSize, x[i], fMinVariables(i));
   }

References fMaxVariables, fMinVariables, fNVariables, fTestQuantity, fTestSampleSize, fTestSqError, fTestVariables, mps_fire::i, dqmiolumiharvest::j, findQualityFiles::size, and x.

◆ Clear()

void TMultiDimFet::Clear ( Option_t * option = "" )

override

Definition at line 360 of file TMultiDimFet.cc.

                                          {
   // Clear internal structures and variables
   Int_t i, j, n = fNVariables, m = fMaxFunctions;
  
   // Training sample, dependent quantity
   fQuantity.Zero();
   fSqError.Zero();
   fMeanQuantity = 0;
   fMaxQuantity = 0;
   fMinQuantity = 0;
   fSumSqQuantity = 0;
   fSumSqAvgQuantity = 0;
  
   // Training sample, independent variables
   fVariables.Zero();
   fNVariables = 0;
   fSampleSize = 0;
   fMeanVariables.Zero();
   fMaxVariables.Zero();
   fMinVariables.Zero();
  
   // Test sample
   fTestQuantity.Zero();
   fTestSqError.Zero();
   fTestVariables.Zero();
   fTestSampleSize = 0;
  
   // Functions
   fFunctions.Zero();
   fMaxFunctions = 0;
   fMaxStudy = 0;
   fMaxFunctionsTimesNVariables = 0;
   fOrthFunctions.Zero();
   fOrthFunctionNorms.Zero();
  
   // Control parameters
   fMinRelativeError = 0;
   fMinAngle = 0;
   fMaxAngle = 0;
   fMaxTerms = 0;
  
   // Powers
   for (i = 0; i < n; i++) {
     fMaxPowers[i] = 0;
     fMaxPowersFinal[i] = 0;
     for (j = 0; j < m; j++)
       fPowers[i * n + j] = 0;
   }
   fPowerLimit = 0;
  
   // Residuals
   fMaxResidual = 0;
   fMinResidual = 0;
   fMaxResidualRow = 0;
   fMinResidualRow = 0;
   fSumSqResidual = 0;
  
   // Fit
   fNCoefficients = 0;
   fOrthCoefficients = 0;
   fOrthCurvatureMatrix = 0;
   fRMS = 0;
   fCorrelationMatrix.Zero();
   fError = 0;
   fTestError = 0;
   fPrecision = 0;
   fTestPrecision = 0;
  
   // Coefficients
   fCoefficients.Zero();
   fCoefficientsRMS.Zero();
   fResiduals.Zero();
   fHistograms->Clear(option);
  
   // Options
   fPolyType = kMonomials;
   fShowCorrelation = kFALSE;
   fIsUserFunction = kFALSE;

References fCoefficients, fCoefficientsRMS, fCorrelationMatrix, fError, fFunctions, fHistograms, fIsUserFunction, fMaxAngle, fMaxFunctions, fMaxFunctionsTimesNVariables, fMaxPowers, fMaxPowersFinal, fMaxQuantity, fMaxResidual, fMaxResidualRow, fMaxStudy, fMaxTerms, fMaxVariables, fMeanQuantity, fMeanVariables, fMinAngle, fMinQuantity, fMinRelativeError, fMinResidual, fMinResidualRow, fMinVariables, fNCoefficients, fNVariables, fOrthCoefficients, fOrthCurvatureMatrix, fOrthFunctionNorms, fOrthFunctions, fPolyType, fPowerLimit, fPowers, fPrecision, fQuantity, fResiduals, fRMS, fSampleSize, fShowCorrelation, fSqError, fSumSqAvgQuantity, fSumSqQuantity, fSumSqResidual, fTestError, fTestPrecision, fTestQuantity, fTestSampleSize, fTestSqError, fTestVariables, fVariables, mps_fire::i, dqmiolumiharvest::j, kMonomials, visualization-live-secondInstance_cfg::m, dqmiodumpmetadata::n, and fileinputsource_cfi::option.

◆ Eval()

Double_t TMultiDimFet::Eval	(	const Double_t *	x,
		const Double_t *	coeff = `nullptr`
	)		const

virtual

Definition at line 441 of file TMultiDimFet.cc.

                                                                           {
   // Evaluate parameterization at point x. Optional argument coeff is
   // a vector of coefficients for the parameterisation, fNCoefficients
   // elements long.
   //   int fMaxFunctionsTimesNVariables = fMaxFunctions * fNVariables;
   Double_t returnValue = fMeanQuantity;
   Double_t term = 0;
   Int_t i, j;
  
   for (i = 0; i < fNCoefficients; i++) {
     // Evaluate the ith term in the expansion
     term = (coeff ? coeff[i] : fCoefficients(i));
     for (j = 0; j < fNVariables; j++) {
       // Evaluate the factor (polynomial) in the j-th variable.
       Int_t p = fPowers[fPowerIndex[i] * fNVariables + j];
       Double_t y = 1 + 2. / (fMaxVariables(j) - fMinVariables(j)) * (x[j] - fMaxVariables(j));
       term *= EvalFactor(p, y);
     }
     // Add this term to the final result
     returnValue += term;
   }
   return returnValue;

References EvalFactor(), fCoefficients, fMaxVariables, fMeanQuantity, fMinVariables, fNCoefficients, fNVariables, fPowerIndex, fPowers, mps_fire::i, dqmiolumiharvest::j, AlCaHLTBitMon_ParallelJobs::p, x, and y.

Referenced by MakeChi2(), LHCOpticsApproximator::Test(), and LHCOpticsApproximator::Transport().

◆ EvalControl()

Double_t TMultiDimFet::EvalControl ( const Int_t * powers )

protectedvirtual

Definition at line 514 of file TMultiDimFet.cc.

                                                   {
   // PRIVATE METHOD:
   // Calculate the control parameter from the passed powers
   Double_t s = 0;
   Double_t epsilon = 1e-6;  // a small number
   for (Int_t i = 0; i < fNVariables; i++) {
     if (fMaxPowers[i] != 1)
       s += (epsilon + iv[i] - 1) / (epsilon + fMaxPowers[i] - 1);
   }
   return s;

References MillePedeFileConverter_cfg::e, geometryDiff::epsilon, fMaxPowers, fNVariables, mps_fire::i, gpuVertexFinder::iv, and alignCSCRings::s.

Referenced by MakeCandidates(), and MakeParameterization().

◆ EvalFactor()

Double_t TMultiDimFet::EvalFactor	(	Int_t	p,
		Double_t	x
	)		const

protectedvirtual

Definition at line 527 of file TMultiDimFet.cc.

                                                            {
   // PRIVATE METHOD:
   // Evaluate function with power p at variable value x
   Int_t i = 0;
   Double_t p1 = 1;
   Double_t p2 = 0;
   Double_t p3 = 0;
   Double_t r = 0;
  
   switch (p) {
     case 1:
       r = 1;
       break;
     case 2:
       r = x;
       break;
     default:
       p2 = x;
       for (i = 3; i <= p; i++) {
         p3 = p2 * x;
         if (fPolyType == kLegendre)
           p3 = ((2 * i - 3) * p2 * x - (i - 2) * p1) / (i - 1);
         else if (fPolyType == kChebyshev)
           p3 = 2 * x * p2 - p1;
         p1 = p2;
         p2 = p3;
       }
       r = p3;
   }
  
   return r;

References fPolyType, mps_fire::i, kChebyshev, kLegendre, AlCaHLTBitMon_ParallelJobs::p, p1, p2, p3, alignCSCRings::r, and x.

Referenced by Eval(), and MakeGramSchmidt().

◆ FindParameterization()

void TMultiDimFet::FindParameterization ( double precision )

virtual

Definition at line 561 of file TMultiDimFet.cc.

                                                         {
   // Find the parameterization
   //
   // Options:
   //     None so far
   //
   // For detailed description of what this entails, please refer to the
   // Begin_Html<a href="#TMultiDimFet:description">class description</a>End_Html
   MakeNormalized();
   MakeCandidates();
   MakeParameterization();
   MakeCoefficients();
   ReducePolynomial(precision);

References MakeCandidates(), MakeCoefficients(), MakeNormalized(), MakeParameterization(), boostedTaus_cff::precision, and ReducePolynomial().

◆ GetChi2()

Double_t TMultiDimFet::GetChi2 ( ) const

inline

Definition at line 155 of file TMultiDimFet.h.

155 { return fMaxFunctions; }

References fMaxFunctions.

◆ GetCoefficients()

const TVectorD* TMultiDimFet::GetCoefficients ( ) const

inline

Definition at line 157 of file TMultiDimFet.h.

157 { return fMaxQuantity; }

References fMaxQuantity.

◆ GetCorrelationMatrix()

const TMatrixD* TMultiDimFet::GetCorrelationMatrix ( ) const

inline

Definition at line 156 of file TMultiDimFet.h.

156 { return fMaxPowers; }

References fMaxPowers.

◆ GetError()

Double_t TMultiDimFet::GetError ( ) const

inline

Definition at line 158 of file TMultiDimFet.h.

158 { return fMaxStudy; }

References fMaxStudy.

◆ GetFunctionCodes()

std::vector<Int_t> TMultiDimFet::GetFunctionCodes ( ) const

inline

Definition at line 159 of file TMultiDimFet.h.

159 { return fMaxTerms; }

References fMaxTerms.

◆ GetFunctions()

const TMatrixD* TMultiDimFet::GetFunctions ( ) const

inline

Definition at line 160 of file TMultiDimFet.h.

160 { return &fMaxVariables; }

References fMaxVariables.

◆ GetHistograms()

virtual TList* TMultiDimFet::GetHistograms ( ) const

inlinevirtual

Definition at line 161 of file TMultiDimFet.h.

161 { return fMeanQuantity; }

References fMeanQuantity.

◆ GetMaxAngle()

Double_t TMultiDimFet::GetMaxAngle ( ) const

inline

Definition at line 162 of file TMultiDimFet.h.

162 { return &fMeanVariables; }

References fMeanVariables.

◆ GetMaxFunctions()

Int_t TMultiDimFet::GetMaxFunctions ( ) const

inline

Definition at line 163 of file TMultiDimFet.h.

163 { return fMinAngle; }

References fMinAngle.

◆ GetMaxPowers()

std::vector<Int_t> TMultiDimFet::GetMaxPowers ( ) const

inline

Definition at line 164 of file TMultiDimFet.h.

164 { return fMinQuantity; }

References fMinQuantity.

◆ GetMaxQuantity()

Double_t TMultiDimFet::GetMaxQuantity ( ) const

inline

Definition at line 165 of file TMultiDimFet.h.

165 { return fMinRelativeError; }

References fMinRelativeError.

◆ GetMaxStudy()

Int_t TMultiDimFet::GetMaxStudy ( ) const

inline

Definition at line 166 of file TMultiDimFet.h.

166 { return &fMinVariables; }

References fMinVariables.

◆ GetMaxTerms()

Int_t TMultiDimFet::GetMaxTerms ( ) const

inline

Definition at line 167 of file TMultiDimFet.h.

167 { return fNVariables; }

References fNVariables.

◆ GetMaxVariables()

const TVectorD* TMultiDimFet::GetMaxVariables ( ) const

inline

Definition at line 168 of file TMultiDimFet.h.

168 { return fNCoefficients; }

References fNCoefficients.

Referenced by LHCOpticsApproximator::ParameterOutOfRangePenalty(), and LHCOpticsApproximator::PrintInputRange().

◆ GetMeanQuantity()

Double_t TMultiDimFet::GetMeanQuantity ( ) const

inline

Definition at line 169 of file TMultiDimFet.h.

169 { return fPolyType; }

References fPolyType.

◆ GetMeanVariables()

const TVectorD* TMultiDimFet::GetMeanVariables ( ) const

inline

Definition at line 170 of file TMultiDimFet.h.

170 { return fPowerIndex; }

References fPowerIndex.

◆ GetMinAngle()

Double_t TMultiDimFet::GetMinAngle ( ) const

inline

Definition at line 171 of file TMultiDimFet.h.

171 { return fPowerLimit; }

References fPowerLimit.

◆ GetMinQuantity()

Double_t TMultiDimFet::GetMinQuantity ( ) const

inline

Definition at line 172 of file TMultiDimFet.h.

172 { return fPowers; }

References fPowers.

◆ GetMinRelativeError()

Double_t TMultiDimFet::GetMinRelativeError ( ) const

inline

Definition at line 173 of file TMultiDimFet.h.

173 { return fPrecision; }

References fPrecision.

◆ GetMinVariables()

const TVectorD* TMultiDimFet::GetMinVariables ( ) const

inline

Definition at line 174 of file TMultiDimFet.h.

174 { return &fQuantity; }

References fQuantity.

Referenced by LHCOpticsApproximator::ParameterOutOfRangePenalty(), and LHCOpticsApproximator::PrintInputRange().

◆ GetNCoefficients()

Int_t TMultiDimFet::GetNCoefficients ( ) const

inline

Definition at line 176 of file TMultiDimFet.h.

176 { return fMinResidual; }

References fMinResidual.

◆ GetNVariables()

Int_t TMultiDimFet::GetNVariables ( ) const

inline

Definition at line 175 of file TMultiDimFet.h.

175 { return fMaxResidual; }

References fMaxResidual.

◆ GetPolyType()

Int_t TMultiDimFet::GetPolyType ( ) const

inline

Definition at line 177 of file TMultiDimFet.h.

177 { return fMaxResidualRow; }

References fMaxResidualRow.

◆ GetPowerIndex()

std::vector<Int_t> TMultiDimFet::GetPowerIndex ( ) const

inline

Definition at line 178 of file TMultiDimFet.h.

178 { return fMinResidualRow; }

References fMinResidualRow.

◆ GetPowerLimit()

Double_t TMultiDimFet::GetPowerLimit ( ) const

inline

Definition at line 179 of file TMultiDimFet.h.

179 { return fSumSqResidual; }

References fSumSqResidual.

◆ GetPowers()

std::vector<Int_t> TMultiDimFet::GetPowers ( ) const

inline

Definition at line 180 of file TMultiDimFet.h.

180 { return fRMS; }

References fRMS.

◆ GetPrecision()

Double_t TMultiDimFet::GetPrecision ( ) const

inline

Definition at line 181 of file TMultiDimFet.h.

181 { return fSampleSize; }

References fSampleSize.

◆ GetQuantity()

const TVectorD* TMultiDimFet::GetQuantity ( ) const

inline

Definition at line 182 of file TMultiDimFet.h.

182 { return &fSqError; }

References fSqError.

◆ GetResidualMax()

Double_t TMultiDimFet::GetResidualMax ( ) const

inline

Definition at line 183 of file TMultiDimFet.h.

183 { return fSumSqAvgQuantity; }

References fSumSqAvgQuantity.

◆ GetResidualMaxRow()

Int_t TMultiDimFet::GetResidualMaxRow ( ) const

inline

Definition at line 185 of file TMultiDimFet.h.

185 { return fTestError; }

References fTestError.

◆ GetResidualMin()

Double_t TMultiDimFet::GetResidualMin ( ) const

inline

Definition at line 184 of file TMultiDimFet.h.

184 { return fSumSqQuantity; }

References fSumSqQuantity.

◆ GetResidualMinRow()

Int_t TMultiDimFet::GetResidualMinRow ( ) const

inline

Definition at line 186 of file TMultiDimFet.h.

186 { return fTestPrecision; }

References fTestPrecision.

◆ GetResidualSumSq()

Double_t TMultiDimFet::GetResidualSumSq ( ) const

inline

Definition at line 187 of file TMultiDimFet.h.

187 { return &fTestQuantity; }

References fTestQuantity.

◆ GetRMS()

Double_t TMultiDimFet::GetRMS ( ) const

inline

Definition at line 188 of file TMultiDimFet.h.

188 { return fTestSampleSize; }

References fTestSampleSize.

◆ GetSampleSize()

Int_t TMultiDimFet::GetSampleSize ( ) const

inline

Definition at line 189 of file TMultiDimFet.h.

189 { return &fTestSqError; }

References fTestSqError.

◆ GetSqError()

const TVectorD* TMultiDimFet::GetSqError ( ) const

inline

Definition at line 190 of file TMultiDimFet.h.

190 { return &fTestVariables; }

References fTestVariables.

◆ GetSumSqAvgQuantity()

Double_t TMultiDimFet::GetSumSqAvgQuantity ( ) const

inline

Definition at line 191 of file TMultiDimFet.h.

191 { return &fVariables; }

References fVariables.

◆ GetSumSqQuantity()

Double_t TMultiDimFet::GetSumSqQuantity ( ) const

inline

Definition at line 192 of file TMultiDimFet.h.

194 { return kTRUE; }

◆ GetTestError()

Double_t TMultiDimFet::GetTestError ( ) const

inline

Definition at line 193 of file TMultiDimFet.h.

194 { return kTRUE; }

◆ GetTestPrecision()

Double_t TMultiDimFet::GetTestPrecision ( ) const

inline

Definition at line 194 of file TMultiDimFet.h.

194 { return kTRUE; }

◆ GetTestQuantity()

const TVectorD* TMultiDimFet::GetTestQuantity ( ) const

inline

Definition at line 195 of file TMultiDimFet.h.

203 { fMaxFunctions = n; }

◆ GetTestSampleSize()

Int_t TMultiDimFet::GetTestSampleSize ( ) const

inline

Definition at line 196 of file TMultiDimFet.h.

203 { fMaxFunctions = n; }

◆ GetTestSqError()

const TVectorD* TMultiDimFet::GetTestSqError ( ) const

inline

Definition at line 197 of file TMultiDimFet.h.

203 { fMaxFunctions = n; }

◆ GetTestVariables()

const TVectorD* TMultiDimFet::GetTestVariables ( ) const

inline

Definition at line 198 of file TMultiDimFet.h.

203 { fMaxFunctions = n; }

◆ GetVariables()

const TVectorD* TMultiDimFet::GetVariables ( ) const

inline

Definition at line 199 of file TMultiDimFet.h.

203 { fMaxFunctions = n; }

◆ IsFolder()

Bool_t TMultiDimFet::IsFolder ( ) const

inlineoverride

Definition at line 202 of file TMultiDimFet.h.

203 { fMaxFunctions = n; }

◆ MakeCandidates()

void TMultiDimFet::MakeCandidates ( )

protectedvirtual

Definition at line 657 of file TMultiDimFet.cc.

                                   {
   // PRIVATE METHOD:
   // Create list of candidate functions for the parameterisation. See
   // also
   // Begin_Html<a href="#TMultiDimFet:description">class description</a>End_Html
   Int_t i = 0;
   Int_t j = 0;
   Int_t k = 0;
  
   // The temporary array to store the powers in. We don't need to
   // initialize this array however.
   Int_t *powers = new Int_t[fNVariables * fMaxFunctions];
  
   // store of `control variables'
   Double_t *control = new Double_t[fMaxFunctions];
  
   // We've better initialize the variables
   Int_t *iv = new Int_t[fNVariables];
   for (i = 0; i < fNVariables; i++)
     iv[i] = 1;
  
   if (!fIsUserFunction) {
     // Number of funcs selected
     Int_t numberFunctions = 0;
  
     // Absolute max number of functions
     Int_t maxNumberFunctions = 1;
     for (i = 0; i < fNVariables; i++)
       maxNumberFunctions *= fMaxPowers[i];
  
     while (kTRUE) {
       // Get the control value for this function
       Double_t s = EvalControl(iv);
  
       if (s <= fPowerLimit) {
         // Call over-loadable method Select, as to allow the user to
         // interfere with the selection of functions.
         if (Select(iv)) {
           numberFunctions++;
  
           // If we've reached the user defined limit of how many
           // functions we can consider, break out of the loop
           if (numberFunctions > fMaxFunctions)
             break;
  
           // Store the control value, so we can sort array of powers
           // later on
           control[numberFunctions - 1] = Int_t(1.0e+6 * s);
  
           // Store the powers in powers array.
           for (i = 0; i < fNVariables; i++) {
             j = (numberFunctions - 1) * fNVariables + i;
             powers[j] = iv[i];
           }
         }  // if (Select())
       }    // if (s <= fPowerLimit)
  
       for (i = 0; i < fNVariables; i++)
         if (iv[i] < fMaxPowers[i])
           break;
  
       // If all variables have reached their maximum power, then we
       // break out of the loop
       if (i == fNVariables) {
         fMaxFunctions = numberFunctions;
         fMaxFunctionsTimesNVariables = fMaxFunctions * fNVariables;
         break;
       }
  
       // Next power in variable i
       iv[i]++;
  
       for (j = 0; j < i; j++)
         iv[j] = 1;
     }  // while (kTRUE)
   } else {
     // In case the user gave an explicit function
     for (i = 0; i < fMaxFunctions; i++) {
       // Copy the powers to working arrays
       for (j = 0; j < fNVariables; j++) {
         powers[i * fNVariables + j] = fPowers[i * fNVariables + j];
         iv[j] = fPowers[i * fNVariables + j];
       }
  
       control[i] = Int_t(1.0e+6 * EvalControl(iv));
     }
   }
  
   // Now we need to sort the powers according to least `control
   // variable'
   Int_t *order = new Int_t[fMaxFunctions];
   for (i = 0; i < fMaxFunctions; i++)
     order[i] = i;
   fPowers.resize(fMaxFunctions * fNVariables);
  
   for (i = 0; i < fMaxFunctions; i++) {
     Double_t x = control[i];
     Int_t l = order[i];
     k = i;
  
     for (j = i; j < fMaxFunctions; j++) {
       if (control[j] <= x) {
         x = control[j];
         l = order[j];
         k = j;
       }
     }
  
     if (k != i) {
       control[k] = control[i];
       control[i] = x;
       order[k] = order[i];
       order[i] = l;
     }
   }
  
   for (i = 0; i < fMaxFunctions; i++)
     for (j = 0; j < fNVariables; j++)
       fPowers[i * fNVariables + j] = powers[order[i] * fNVariables + j];
  
   delete[] control;
   delete[] powers;
   delete[] order;
   delete[] iv;

References MillePedeFileConverter_cfg::e, EvalControl(), fIsUserFunction, fMaxFunctions, fMaxFunctionsTimesNVariables, fMaxPowers, fNVariables, fPowerLimit, fPowers, mps_fire::i, gpuVertexFinder::iv, dqmiolumiharvest::j, dqmdumpme::k, cmsLHEtoEOSManager::l, eventshapeDQM_cfi::order, alignCSCRings::s, Select(), and x.

Referenced by FindParameterization().

◆ MakeChi2()

Double_t TMultiDimFet::MakeChi2 ( const Double_t * coeff = nullptr )

virtual

Definition at line 783 of file TMultiDimFet.cc.

                                                      {
   // Calculate Chi square over either the test sample. The optional
   // argument coeff is a vector of coefficients to use in the
   // evaluation of the parameterisation. If coeff == 0, then the found
   // coefficients is used.
   // Used my MINUIT for fit (see TMultDimFit::Fit)
   fChi2 = 0;
   Int_t i, j;
   Double_t *x = new Double_t[fNVariables];
   for (i = 0; i < fTestSampleSize; i++) {
     // Get the stored point
     for (j = 0; j < fNVariables; j++)
       x[j] = fTestVariables(i * fNVariables + j);
  
     // Evaluate function. Scale to shifted values
     Double_t f = Eval(x, coeff);
  
     // Calculate contribution to Chic square
     fChi2 += 1. / TMath::Max(fTestSqError(i), 1e-20) * (fTestQuantity(i) - f) * (fTestQuantity(i) - f);
   }
  
   // Clean up
   delete[] x;
  
   return fChi2;

References MillePedeFileConverter_cfg::e, Eval(), f, fChi2, fNVariables, fTestQuantity, fTestSampleSize, fTestSqError, fTestVariables, mps_fire::i, dqmiolumiharvest::j, Max(), and x.

◆ MakeCode()

void TMultiDimFet::MakeCode	(	const char *	functionName = `"MDF"`,
		Option_t *	option = `""`
	)

virtual

Definition at line 811 of file TMultiDimFet.cc.

                                                                   {
   // Generate the file <filename> with .C appended if argument doesn't
   // end in .cxx or .C. The contains the implementation of the
   // function:
   //
   //   Double_t <funcname>(Double_t *x)
   //
   // which does the same as TMultiDimFet::Eval. Please refer to this
   // method.
   //
   // Further, the static variables:
   //
   //     Int_t    gNVariables
   //     Int_t    gNCoefficients
   //     Double_t gDMean
   //     Double_t gXMean[]
   //     Double_t gXMin[]
   //     Double_t gXMax[]
   //     Double_t gCoefficient[]
   //     Int_t    gPower[]
   //
   // are initialized. The only ROOT header file needed is Rtypes.h
   //
   // See TMultiDimFet::MakeRealCode for a list of options
  
   TString outName(filename);
   if (!outName.EndsWith(".C") && !outName.EndsWith(".cxx"))
     outName += ".C";
  
   MakeRealCode(outName.Data(), "", option);

References corrVsCorr::filename, MakeRealCode(), fileinputsource_cfi::option, and dataset::outName.

◆ MakeCoefficientErrors()

void TMultiDimFet::MakeCoefficientErrors ( )

protectedvirtual

Definition at line 843 of file TMultiDimFet.cc.

                                          {
   // PRIVATE METHOD:
   // Compute the errors on the coefficients. For this to be done, the
   // curvature matrix of the non-orthogonal functions, is computed.
   Int_t i = 0;
   Int_t j = 0;
   Int_t k = 0;
   TVectorD iF(fSampleSize);
   TVectorD jF(fSampleSize);
   fCoefficientsRMS.ResizeTo(fNCoefficients);
  
   TMatrixDSym curvatureMatrix(fNCoefficients);
  
   // Build the curvature matrix
   for (i = 0; i < fNCoefficients; i++) {
     iF = TMatrixDRow(fFunctions, i);
     for (j = 0; j <= i; j++) {
       jF = TMatrixDRow(fFunctions, j);
       for (k = 0; k < fSampleSize; k++)
         curvatureMatrix(i, j) += 1 / TMath::Max(fSqError(k), 1e-20) * iF(k) * jF(k);
       curvatureMatrix(j, i) = curvatureMatrix(i, j);
     }
   }
  
   // Calculate Chi Square
   fChi2 = 0;
   for (i = 0; i < fSampleSize; i++) {
     Double_t f = 0;
     for (j = 0; j < fNCoefficients; j++)
       f += fCoefficients(j) * fFunctions(j, i);
     fChi2 += 1. / TMath::Max(fSqError(i), 1e-20) * (fQuantity(i) - f) * (fQuantity(i) - f);
   }
  
   // Invert the curvature matrix
   const TVectorD diag = TMatrixDDiag_const(curvatureMatrix);
   curvatureMatrix.NormByDiag(diag);
  
   TDecompChol chol(curvatureMatrix);
   if (!chol.Decompose())
     Error("MakeCoefficientErrors", "curvature matrix is singular");
   chol.Invert(curvatureMatrix);
  
   curvatureMatrix.NormByDiag(diag);
  
   for (i = 0; i < fNCoefficients; i++)
     fCoefficientsRMS(i) = TMath::Sqrt(curvatureMatrix(i, i));

References MillePedeFileConverter_cfg::e, f, fChi2, fCoefficients, fCoefficientsRMS, fFunctions, fNCoefficients, fQuantity, fSampleSize, fSqError, mps_fire::i, dqmiolumiharvest::j, dqmdumpme::k, and Max().

◆ MakeCoefficients()

void TMultiDimFet::MakeCoefficients ( )

protectedvirtual

Definition at line 892 of file TMultiDimFet.cc.

                                     {
   // PRIVATE METHOD:
   // Invert the model matrix B, and compute final coefficients. For a
   // more thorough discussion of what this means, please refer to the
   // Begin_Html<a href="#TMultiDimFet:description">class description</a>End_Html
   //
   // First we invert the lower triangle matrix fOrthCurvatureMatrix
   // and store the inverted matrix in the upper triangle.
  
   Int_t i = 0, j = 0;
   Int_t col = 0, row = 0;
  
   // Invert the B matrix
   for (col = 1; col < fNCoefficients; col++) {
     for (row = col - 1; row > -1; row--) {
       fOrthCurvatureMatrix(row, col) = 0;
       for (i = row; i <= col; i++)
         fOrthCurvatureMatrix(row, col) -= fOrthCurvatureMatrix(i, row) * fOrthCurvatureMatrix(i, col);
     }
   }
  
   // Compute the final coefficients
   fCoefficients.ResizeTo(fNCoefficients);
  
   for (i = 0; i < fNCoefficients; i++) {
     Double_t sum = 0;
     for (j = i; j < fNCoefficients; j++)
       sum += fOrthCurvatureMatrix(i, j) * fOrthCoefficients(j);
     fCoefficients(i) = sum;
   }
  
   // Compute the final residuals
   fResiduals.ResizeTo(fSampleSize);
   for (i = 0; i < fSampleSize; i++)
     fResiduals(i) = fQuantity(i);
  
   for (i = 0; i < fNCoefficients; i++)
     for (j = 0; j < fSampleSize; j++)
       fResiduals(j) -= fCoefficients(i) * fFunctions(i, j);
  
   // Compute the max and minimum, and squared sum of the evaluated
   // residuals
   fMinResidual = 10e10;
   fMaxResidual = -10e10;
   Double_t sqRes = 0;
   for (i = 0; i < fSampleSize; i++) {
     sqRes += fResiduals(i) * fResiduals(i);
     if (fResiduals(i) <= fMinResidual) {
       fMinResidual = fResiduals(i);
       fMinResidualRow = i;
     }
     if (fResiduals(i) >= fMaxResidual) {
       fMaxResidual = fResiduals(i);
       fMaxResidualRow = i;
     }
   }
  
   fCorrelationCoeff = fSumSqResidual / fSumSqAvgQuantity;
   fPrecision = TMath::Sqrt(sqRes / fSumSqQuantity);
  
   // If we use histograms, fill some more
   if (TESTBIT(fHistogramMask, HIST_RD) || TESTBIT(fHistogramMask, HIST_RTRAI) || TESTBIT(fHistogramMask, HIST_RX)) {
     for (i = 0; i < fSampleSize; i++) {
       if (TESTBIT(fHistogramMask, HIST_RD))
         ((TH2D *)fHistograms->FindObject("res_d"))->Fill(fQuantity(i), fResiduals(i));
       if (TESTBIT(fHistogramMask, HIST_RTRAI))
         ((TH1D *)fHistograms->FindObject("res_train"))->Fill(fResiduals(i));
  
       if (TESTBIT(fHistogramMask, HIST_RX))
         for (j = 0; j < fNVariables; j++)
           ((TH2D *)fHistograms->FindObject(Form("res_x_%d", j)))->Fill(fVariables(i * fNVariables + j), fResiduals(i));
     }
   }  // If histograms

References cuy::col, fCoefficients, fCorrelationCoeff, fFunctions, fHistogramMask, fHistograms, HcalObjRepresent::Fill(), fMaxResidual, fMaxResidualRow, fMinResidual, fMinResidualRow, fNCoefficients, fNVariables, fOrthCoefficients, fOrthCurvatureMatrix, fPrecision, fQuantity, fResiduals, fSampleSize, fSumSqAvgQuantity, fSumSqQuantity, fSumSqResidual, fVariables, HIST_RD, HIST_RTRAI, HIST_RX, mps_fire::i, and dqmiolumiharvest::j.

Referenced by FindParameterization().

◆ MakeCorrelation()

void TMultiDimFet::MakeCorrelation ( )

protectedvirtual

Definition at line 968 of file TMultiDimFet.cc.

                                    {
   // PRIVATE METHOD:
   // Compute the correlation matrix
   if (!fShowCorrelation)
     return;
  
   fCorrelationMatrix.ResizeTo(fNVariables, fNVariables + 1);
  
   Double_t d2 = 0;
   Double_t ddotXi = 0;   // G.Q. needs to be reinitialized in the loop over i fNVariables
   Double_t xiNorm = 0;   // G.Q. needs to be reinitialized in the loop over i fNVariables
   Double_t xidotXj = 0;  // G.Q. needs to be reinitialized in the loop over j fNVariables
   Double_t xjNorm = 0;   // G.Q. needs to be reinitialized in the loop over j fNVariables
  
   Int_t i, j, k, l, m;  // G.Q. added m variable
   for (i = 0; i < fSampleSize; i++)
     d2 += fQuantity(i) * fQuantity(i);
  
   for (i = 0; i < fNVariables; i++) {
     ddotXi = 0.;  // G.Q. reinitialisation
     xiNorm = 0.;  // G.Q. reinitialisation
     for (j = 0; j < fSampleSize; j++) {
       // Index of sample j of variable i
       k = j * fNVariables + i;
       ddotXi += fQuantity(j) * (fVariables(k) - fMeanVariables(i));
       xiNorm += (fVariables(k) - fMeanVariables(i)) * (fVariables(k) - fMeanVariables(i));
     }
     fCorrelationMatrix(i, 0) = ddotXi / TMath::Sqrt(d2 * xiNorm);
  
     for (j = 0; j < i; j++) {
       xidotXj = 0.;  // G.Q. reinitialisation
       xjNorm = 0.;   // G.Q. reinitialisation
       for (k = 0; k < fSampleSize; k++) {
         // Index of sample j of variable i
         // l =  j * fNVariables + k;  // G.Q.
         l = k * fNVariables + j;  // G.Q.
         m = k * fNVariables + i;  // G.Q.
         // G.Q.        xidotXj += (fVariables(i) - fMeanVariables(i))
         // G.Q.          * (fVariables(l) - fMeanVariables(j));
         xidotXj +=
             (fVariables(m) - fMeanVariables(i)) * (fVariables(l) - fMeanVariables(j));  // G.Q. modified index for Xi
         xjNorm += (fVariables(l) - fMeanVariables(j)) * (fVariables(l) - fMeanVariables(j));
       }
       fCorrelationMatrix(i, j + 1) = xidotXj / TMath::Sqrt(xiNorm * xjNorm);
     }
   }

References fCorrelationMatrix, fMeanVariables, fNVariables, fQuantity, fSampleSize, fShowCorrelation, fVariables, mps_fire::i, dqmiolumiharvest::j, dqmdumpme::k, cmsLHEtoEOSManager::l, and visualization-live-secondInstance_cfg::m.

◆ MakeGramSchmidt()

Double_t TMultiDimFet::MakeGramSchmidt ( Int_t function )

protectedvirtual

Definition at line 1017 of file TMultiDimFet.cc.

                                                      {
   // PRIVATE METHOD:
   // Make Gram-Schmidt orthogonalisation. The class description gives
   // a thorough account of this algorithm, as well as
   // references. Please refer to the
   // Begin_Html<a href="#TMultiDimFet:description">class description</a>End_Html
  
   // calculate w_i, that is, evaluate the current function at data
   // point i
   Double_t f2 = 0;
   fOrthCoefficients(fNCoefficients) = 0;
   fOrthFunctionNorms(fNCoefficients) = 0;
   Int_t j = 0;
   Int_t k = 0;
  
   for (j = 0; j < fSampleSize; j++) {
     fFunctions(fNCoefficients, j) = 1;
     fOrthFunctions(fNCoefficients, j) = 0;
     // First, however, we need to calculate f_fNCoefficients
     for (k = 0; k < fNVariables; k++) {
       Int_t p = fPowers[function * fNVariables + k];
       Double_t x = fVariables(j * fNVariables + k);
       fFunctions(fNCoefficients, j) *= EvalFactor(p, x);
     }
  
     // Calculate f dot f in f2
     f2 += fFunctions(fNCoefficients, j) * fFunctions(fNCoefficients, j);
     // Assign to w_fNCoefficients f_fNCoefficients
     fOrthFunctions(fNCoefficients, j) = fFunctions(fNCoefficients, j);
   }
  
   // the first column of w is equal to f
   for (j = 0; j < fNCoefficients; j++) {
     Double_t fdw = 0;
     // Calculate (f_fNCoefficients dot w_j) / w_j^2
     for (k = 0; k < fSampleSize; k++) {
       fdw += fFunctions(fNCoefficients, k) * fOrthFunctions(j, k) / fOrthFunctionNorms(j);
     }
  
     fOrthCurvatureMatrix(fNCoefficients, j) = fdw;
     // and subtract it from the current value of w_ij
     for (k = 0; k < fSampleSize; k++)
       fOrthFunctions(fNCoefficients, k) -= fdw * fOrthFunctions(j, k);
   }
  
   for (j = 0; j < fSampleSize; j++) {
     // calculate squared length of w_fNCoefficients
     fOrthFunctionNorms(fNCoefficients) += fOrthFunctions(fNCoefficients, j) * fOrthFunctions(fNCoefficients, j);
  
     // calculate D dot w_fNCoefficients in A
     fOrthCoefficients(fNCoefficients) += fQuantity(j) * fOrthFunctions(fNCoefficients, j);
   }
  
   // First test, but only if didn't user specify
   if (!fIsUserFunction)
     if (TMath::Sqrt(fOrthFunctionNorms(fNCoefficients) / (f2 + 1e-10)) < TMath::Sin(fMinAngle * DEGRAD))
       return 0;
  
   // The result found by this code for the first residual is always
   // much less then the one found be MUDIFI. That's because it's
   // supposed to be. The cause is the improved precision of Double_t
   // over DOUBLE PRECISION!
   fOrthCurvatureMatrix(fNCoefficients, fNCoefficients) = 1;
   Double_t b = fOrthCoefficients(fNCoefficients);
   fOrthCoefficients(fNCoefficients) /= fOrthFunctionNorms(fNCoefficients);
  
   // Calculate the residual from including this fNCoefficients.
   Double_t dResidur = fOrthCoefficients(fNCoefficients) * b;
  
   return dResidur;

References b, DEGRAD, MillePedeFileConverter_cfg::e, EvalFactor(), DeadROC_duringRun::f2, fFunctions, fIsUserFunction, fMinAngle, fNCoefficients, fNVariables, fOrthCoefficients, fOrthCurvatureMatrix, fOrthFunctionNorms, fOrthFunctions, fPowers, fQuantity, fSampleSize, fVariables, dqmiolumiharvest::j, dqmdumpme::k, AlCaHLTBitMon_ParallelJobs::p, and x.

Referenced by MakeParameterization().

◆ MakeHistograms()

void TMultiDimFet::MakeHistograms ( Option_t * option = "A" )

virtual

Definition at line 1090 of file TMultiDimFet.cc.

                                                   {
   // Make histograms of the result of the analysis. This message
   // should be sent after having read all data points, but before
   // finding the parameterization
   //
   // Options:
   //     A         All the below
   //     X         Original independent variables
   //     D         Original dependent variables
   //     N         Normalised independent variables
   //     S         Shifted dependent variables
   //     R1        Residuals versus normalised independent variables
   //     R2        Residuals versus dependent variable
   //     R3        Residuals computed on training sample
   //     R4        Residuals computed on test sample
   //
   // For a description of these quantities, refer to
   // Begin_Html<a href="#TMultiDimFet:description">class description</a>End_Html
   TString opt(option);
   opt.ToLower();
  
   if (opt.Length() < 1)
     return;
  
   if (!fHistograms)
     fHistograms = new TList;
  
   // Counter variable
   Int_t i = 0;
  
   // Histogram of original variables
   if (opt.Contains("x") || opt.Contains("a")) {
     SETBIT(fHistogramMask, HIST_XORIG);
     for (i = 0; i < fNVariables; i++)
       if (!fHistograms->FindObject(Form("x_%d_orig", i)))
         fHistograms->Add(
             new TH1D(Form("x_%d_orig", i), Form("Original variable # %d", i), 100, fMinVariables(i), fMaxVariables(i)));
   }
  
   // Histogram of original dependent variable
   if (opt.Contains("d") || opt.Contains("a")) {
     SETBIT(fHistogramMask, HIST_DORIG);
     if (!fHistograms->FindObject("d_orig"))
       fHistograms->Add(new TH1D("d_orig", "Original Quantity", 100, fMinQuantity, fMaxQuantity));
   }
  
   // Histograms of normalized variables
   if (opt.Contains("n") || opt.Contains("a")) {
     SETBIT(fHistogramMask, HIST_XNORM);
     for (i = 0; i < fNVariables; i++)
       if (!fHistograms->FindObject(Form("x_%d_norm", i)))
         fHistograms->Add(new TH1D(Form("x_%d_norm", i), Form("Normalized variable # %d", i), 100, -1, 1));
   }
  
   // Histogram of shifted dependent variable
   if (opt.Contains("s") || opt.Contains("a")) {
     SETBIT(fHistogramMask, HIST_DSHIF);
     if (!fHistograms->FindObject("d_shifted"))
       fHistograms->Add(
           new TH1D("d_shifted", "Shifted Quantity", 100, fMinQuantity - fMeanQuantity, fMaxQuantity - fMeanQuantity));
   }
  
   // Residual from training sample versus independent variables
   if (opt.Contains("r1") || opt.Contains("a")) {
     SETBIT(fHistogramMask, HIST_RX);
     for (i = 0; i < fNVariables; i++)
       if (!fHistograms->FindObject(Form("res_x_%d", i)))
         fHistograms->Add(new TH2D(Form("res_x_%d", i),
                                   Form("Computed residual versus x_%d", i),
                                   100,
                                   -1,
                                   1,
                                   35,
                                   fMinQuantity - fMeanQuantity,
                                   fMaxQuantity - fMeanQuantity));
   }
  
   // Residual from training sample versus. dependent variable
   if (opt.Contains("r2") || opt.Contains("a")) {
     SETBIT(fHistogramMask, HIST_RD);
     if (!fHistograms->FindObject("res_d"))
       fHistograms->Add(new TH2D("res_d",
                                 "Computed residuals vs Quantity",
                                 100,
                                 fMinQuantity - fMeanQuantity,
                                 fMaxQuantity - fMeanQuantity,
                                 35,
                                 fMinQuantity - fMeanQuantity,
                                 fMaxQuantity - fMeanQuantity));
   }
  
   // Residual from training sample
   if (opt.Contains("r3") || opt.Contains("a")) {
     SETBIT(fHistogramMask, HIST_RTRAI);
     if (!fHistograms->FindObject("res_train"))
       fHistograms->Add(new TH1D("res_train",
                                 "Computed residuals over training sample",
                                 100,
                                 fMinQuantity - fMeanQuantity,
                                 fMaxQuantity - fMeanQuantity));
   }
   if (opt.Contains("r4") || opt.Contains("a")) {
     SETBIT(fHistogramMask, HIST_RTEST);
     if (!fHistograms->FindObject("res_test"))
       fHistograms->Add(new TH1D("res_test",
                                 "Distribution of residuals from test",
                                 100,
                                 fMinQuantity - fMeanQuantity,
                                 fMaxQuantity - fMeanQuantity));
   }

References fHistogramMask, fHistograms, fMaxQuantity, fMaxVariables, fMeanQuantity, fMinQuantity, fMinVariables, fNVariables, HIST_DORIG, HIST_DSHIF, HIST_RD, HIST_RTEST, HIST_RTRAI, HIST_RX, HIST_XNORM, HIST_XORIG, mps_fire::i, runTheMatrix::opt, and fileinputsource_cfi::option.

◆ MakeMethod()

void TMultiDimFet::MakeMethod	(	const Char_t *	className = `"MDF"`,
		Option_t *	option = `""`
	)

virtual

Definition at line 1203 of file TMultiDimFet.cc.

                                                                        {
   // Generate the file <classname>MDF.cxx which contains the
   // implementation of the method:
   //
   //   Double_t <classname>::MDF(Double_t *x)
   //
   // which does the same as  TMultiDimFet::Eval. Please refer to this
   // method.
   //
   // Further, the public static members:
   //
   //   Int_t    <classname>::fgNVariables
   //   Int_t    <classname>::fgNCoefficients
   //   Double_t <classname>::fgDMean
   //   Double_t <classname>::fgXMean[]       //[fgNVariables]
   //   Double_t <classname>::fgXMin[]        //[fgNVariables]
   //   Double_t <classname>::fgXMax[]        //[fgNVariables]
   //   Double_t <classname>::fgCoefficient[] //[fgNCoeffficents]
   //   Int_t    <classname>::fgPower[]       //[fgNCoeffficents*fgNVariables]
   //
   // are initialized, and assumed to exist. The class declaration is
   // assumed to be in <classname>.h and assumed to be provided by the
   // user.
   //
   // See TMultiDimFet::MakeRealCode for a list of options
   //
   // The minimal class definition is:
   //
   //   class <classname> {
   //   public:
   //     Int_t    <classname>::fgNVariables;     // Number of variables
   //     Int_t    <classname>::fgNCoefficients;  // Number of terms
   //     Double_t <classname>::fgDMean;          // Mean from training sample
   //     Double_t <classname>::fgXMean[];        // Mean from training sample
   //     Double_t <classname>::fgXMin[];         // Min from training sample
   //     Double_t <classname>::fgXMax[];         // Max from training sample
   //     Double_t <classname>::fgCoefficient[];  // Coefficients
   //     Int_t    <classname>::fgPower[];        // Function powers
   //
   //     Double_t Eval(Double_t *x);
   //   };
   //
   // Whether the method <classname>::Eval should be static or not, is
   // up to the user.
  
   MakeRealCode(Form("%sMDF.cxx", classname), classname, option);

References data-class-funcs::classname, MakeRealCode(), and fileinputsource_cfi::option.

◆ MakeNormalized()

void TMultiDimFet::MakeNormalized ( )

protectedvirtual

Definition at line 1252 of file TMultiDimFet.cc.

                                   {
   // PRIVATE METHOD:
   // Normalize data to the interval [-1;1]. This is needed for the
   // classes method to work.
  
   Int_t i = 0;
   Int_t j = 0;
   Int_t k = 0;
  
   for (i = 0; i < fSampleSize; i++) {
     if (TESTBIT(fHistogramMask, HIST_DORIG))
       ((TH1D *)fHistograms->FindObject("d_orig"))->Fill(fQuantity(i));
  
     fQuantity(i) -= fMeanQuantity;
     fSumSqAvgQuantity += fQuantity(i) * fQuantity(i);
  
     if (TESTBIT(fHistogramMask, HIST_DSHIF))
       ((TH1D *)fHistograms->FindObject("d_shifted"))->Fill(fQuantity(i));
  
     for (j = 0; j < fNVariables; j++) {
       Double_t range = 1. / (fMaxVariables(j) - fMinVariables(j));
       k = i * fNVariables + j;
  
       // Fill histograms of original independent variables
       if (TESTBIT(fHistogramMask, HIST_XORIG))
         ((TH1D *)fHistograms->FindObject(Form("x_%d_orig", j)))->Fill(fVariables(k));
  
       // Normalise independent variables
       fVariables(k) = 1 + 2 * range * (fVariables(k) - fMaxVariables(j));
  
       // Fill histograms of normalised independent variables
       if (TESTBIT(fHistogramMask, HIST_XNORM))
         ((TH1D *)fHistograms->FindObject(Form("x_%d_norm", j)))->Fill(fVariables(k));
     }
   }
   // Shift min and max of dependent variable
   fMaxQuantity -= fMeanQuantity;
   fMinQuantity -= fMeanQuantity;
  
   // Shift mean of independent variables
   for (i = 0; i < fNVariables; i++) {
     Double_t range = 1. / (fMaxVariables(i) - fMinVariables(i));
     fMeanVariables(i) = 1 + 2 * range * (fMeanVariables(i) - fMaxVariables(i));
   }

References fHistogramMask, fHistograms, HcalObjRepresent::Fill(), fMaxQuantity, fMaxVariables, fMeanQuantity, fMeanVariables, fMinQuantity, fMinVariables, fNVariables, fQuantity, fSampleSize, fSumSqAvgQuantity, fVariables, HIST_DORIG, HIST_DSHIF, HIST_XNORM, HIST_XORIG, mps_fire::i, dqmiolumiharvest::j, dqmdumpme::k, and FastTimerService_cff::range.

Referenced by FindParameterization().

◆ MakeParameterization()

void TMultiDimFet::MakeParameterization ( )

protectedvirtual

Definition at line 1299 of file TMultiDimFet.cc.

                                         {
   // PRIVATE METHOD:
   // Find the parameterization over the training sample. A full account
   // of the algorithm is given in the
   // Begin_Html<a href="#TMultiDimFet:description">class description</a>End_Html
  
   Int_t i = -1;
   Int_t j = 0;
   Int_t k = 0;
   Int_t maxPass = 3;
   Int_t studied = 0;
   Double_t squareResidual = fSumSqAvgQuantity;
   fNCoefficients = 0;
   fSumSqResidual = fSumSqAvgQuantity;
   fFunctions.ResizeTo(fMaxTerms, fSampleSize);
   fOrthFunctions.ResizeTo(fMaxTerms, fSampleSize);
   fOrthFunctionNorms.ResizeTo(fMaxTerms);
   fOrthCoefficients.ResizeTo(fMaxTerms);
   fOrthCurvatureMatrix.ResizeTo(fMaxTerms, fMaxTerms);
   fFunctions = 1;
  
   fFunctionCodes.resize(fMaxFunctions);
   fPowerIndex.resize(fMaxTerms);
   Int_t l;
   for (l = 0; l < fMaxFunctions; l++)
     fFunctionCodes[l] = 0;
   for (l = 0; l < fMaxTerms; l++)
     fPowerIndex[l] = 0;
  
   if (fMaxAngle != 0)
     maxPass = 100;
   if (fIsUserFunction)
     maxPass = 1;
  
   // Loop over the number of functions we want to study.
   // increment inspection counter
   while (kTRUE) {
     // Reach user defined limit of studies
     if (studied++ >= fMaxStudy) {
       fParameterisationCode = PARAM_MAXSTUDY;
       break;
     }
  
     // Considered all functions several times
     if (k >= maxPass) {
       fParameterisationCode = PARAM_SEVERAL;
       break;
     }
  
     // increment function counter
     i++;
  
     // If we've reached the end of the functions, restart pass
     if (i == fMaxFunctions) {
       if (fMaxAngle != 0)
         fMaxAngle += (90 - fMaxAngle) / 2;
       i = 0;
       studied--;
       k++;
       continue;
     }
     if (studied == 1)
       fFunctionCodes[i] = 0;
     else if (fFunctionCodes[i] >= 2)
       continue;
  
     // Print a happy message
     if (fIsVerbose && studied == 1)
       edm::LogInfo("TMultiDimFet") << "Coeff   SumSqRes    Contrib   Angle      QM   Func"
                                    << "     Value        W^2  Powers"
                                    << "\n";
  
     // Make the Gram-Schmidt
     Double_t dResidur = MakeGramSchmidt(i);
  
     if (dResidur == 0) {
       // This function is no good!
       // First test is in MakeGramSchmidt
       fFunctionCodes[i] = 1;
       continue;
     }
  
     // If user specified function, assume she/he knows what he's doing
     if (!fIsUserFunction) {
       // Flag this function as considered
       fFunctionCodes[i] = 2;
  
       // Test if this function contributes to the fit
       if (!TestFunction(squareResidual, dResidur)) {
         fFunctionCodes[i] = 1;
         continue;
       }
     }
  
     // If we get to here, the function currently considered is
     // fNCoefficients, so we increment the counter
     // Flag this function as OK, and store and the number in the
     // index.
     fFunctionCodes[i] = 3;
     fPowerIndex[fNCoefficients] = i;
     fNCoefficients++;
  
     // We add the current contribution to the sum of square of
     // residuals;
     squareResidual -= dResidur;
  
     // Calculate control parameter from this function
     for (j = 0; j < fNVariables; j++) {
       if (fNCoefficients == 1 || fMaxPowersFinal[j] <= fPowers[i * fNVariables + j] - 1)
         fMaxPowersFinal[j] = fPowers[i * fNVariables + j] - 1;
     }
     Double_t s = EvalControl(&fPowers[i * fNVariables]);
  
     // Print the statistics about this function
     if (fIsVerbose) {
       edm::LogVerbatim("TMultiDimFet") << std::setw(5) << fNCoefficients << " " << std::setw(10) << std::setprecision(4)
                                        << squareResidual << " " << std::setw(10) << std::setprecision(4) << dResidur
                                        << " " << std::setw(7) << std::setprecision(3) << fMaxAngle << " "
                                        << std::setw(7) << std::setprecision(3) << s << " " << std::setw(5) << i << " "
                                        << std::setw(10) << std::setprecision(4) << fOrthCoefficients(fNCoefficients - 1)
                                        << " " << std::setw(10) << std::setprecision(4)
                                        << fOrthFunctionNorms(fNCoefficients - 1) << " " << std::flush;
       for (j = 0; j < fNVariables; j++)
         edm::LogInfo("TMultiDimFet") << " " << fPowers[i * fNVariables + j] - 1 << std::flush;
       edm::LogInfo("TMultiDimFet") << "\n";
     }
  
     if (fNCoefficients >= fMaxTerms /* && fIsVerbose */) {
       fParameterisationCode = PARAM_MAXTERMS;
       break;
     }
  
     Double_t err = TMath::Sqrt(TMath::Max(1e-20, squareResidual) / fSumSqAvgQuantity);
     if (err < fMinRelativeError) {
       fParameterisationCode = PARAM_RELERR;
       break;
     }
   }
  
   fError = TMath::Max(1e-20, squareResidual);
   fSumSqResidual -= fError;
   fRMS = TMath::Sqrt(fError / fSampleSize);

References MillePedeFileConverter_cfg::e, submitPVResolutionJobs::err, EvalControl(), fError, fFunctionCodes, fFunctions, fIsUserFunction, fIsVerbose, fMaxAngle, fMaxFunctions, fMaxPowersFinal, fMaxStudy, fMaxTerms, fMinRelativeError, fNCoefficients, fNVariables, fOrthCoefficients, fOrthCurvatureMatrix, fOrthFunctionNorms, fOrthFunctions, fParameterisationCode, fPowerIndex, fPowers, fRMS, fSampleSize, fSumSqAvgQuantity, fSumSqResidual, mps_fire::i, dqmiolumiharvest::j, dqmdumpme::k, cmsLHEtoEOSManager::l, MakeGramSchmidt(), Max(), PARAM_MAXSTUDY, PARAM_MAXTERMS, PARAM_RELERR, PARAM_SEVERAL, alignCSCRings::s, and TestFunction().

Referenced by FindParameterization().

◆ MakeRealCode()

void TMultiDimFet::MakeRealCode	(	const char *	filename,
		const char *	classname,
		Option_t *	option = `""`
	)

protectedvirtual

Definition at line 1444 of file TMultiDimFet.cc.

                                                                                        {
   // PRIVATE METHOD:
   // This is the method that actually generates the code for the
   // evaluation the parameterization on some point.
   // It's called by TMultiDimFet::MakeCode and TMultiDimFet::MakeMethod.
   //
   // The options are: NONE so far
   Int_t i, j;
  
   Bool_t isMethod = (classname[0] == '\0' ? kFALSE : kTRUE);
   const char *prefix = (isMethod ? Form("%s::", classname) : "");
   const char *cv_qual = (isMethod ? "" : "static ");
  
   std::ofstream outFile(filename, std::ios::out | std::ios::trunc);
   if (!outFile) {
     Error("MakeRealCode", "couldn't open output file '%s'", filename);
     return;
   }
  
   if (fIsVerbose)
     edm::LogInfo("TMultiDimFet") << "Writing on file \"" << filename << "\" ... " << std::flush;
   //
   // Write header of file
   //
   // Emacs mode line ;-)
   outFile << "// -*- mode: c++ -*-"
           << "\n";
   // Info about creator
   outFile << "// "
           << "\n"
           << "// File " << filename << " generated by TMultiDimFet::MakeRealCode"
           << "\n";
   // Time stamp
   TDatime date;
   outFile << "// on " << date.AsString() << "\n";
   // ROOT version info
   outFile << "// ROOT version " << gROOT->GetVersion() << "\n"
           << "//"
           << "\n";
   // General information on the code
   outFile << "// This file contains the function "
           << "\n"
           << "//"
           << "\n"
           << "//    double  " << prefix << "MDF(double *x); "
           << "\n"
           << "//"
           << "\n"
           << "// For evaluating the parameterization obtained"
           << "\n"
           << "// from TMultiDimFet and the point x"
           << "\n"
           << "// "
           << "\n"
           << "// See TMultiDimFet class documentation for more "
           << "information "
           << "\n"
           << "// "
           << "\n";
   // Header files
   if (isMethod)
     // If these are methods, we need the class header
     outFile << "#include \"" << classname << ".h\""
             << "\n";
  
   //
   // Now for the data
   //
   outFile << "//"
           << "\n"
           << "// Static data variables"
           << "\n"
           << "//"
           << "\n";
   outFile << cv_qual << "int    " << prefix << "gNVariables    = " << fNVariables << ";"
           << "\n";
   outFile << cv_qual << "int    " << prefix << "gNCoefficients = " << fNCoefficients << ";"
           << "\n";
   outFile << cv_qual << "double " << prefix << "gDMean         = " << fMeanQuantity << ";"
           << "\n";
  
   // Assignment to mean vector.
   outFile << "// Assignment to mean vector."
           << "\n";
   outFile << cv_qual << "double " << prefix << "gXMean[] = {"
           << "\n";
   for (i = 0; i < fNVariables; i++)
     outFile << (i != 0 ? ", " : "  ") << fMeanVariables(i) << std::flush;
   outFile << " };"
           << "\n"
           << "\n";
  
   // Assignment to minimum vector.
   outFile << "// Assignment to minimum vector."
           << "\n";
   outFile << cv_qual << "double " << prefix << "gXMin[] = {"
           << "\n";
   for (i = 0; i < fNVariables; i++)
     outFile << (i != 0 ? ", " : "  ") << fMinVariables(i) << std::flush;
   outFile << " };"
           << "\n"
           << "\n";
  
   // Assignment to maximum vector.
   outFile << "// Assignment to maximum vector."
           << "\n";
   outFile << cv_qual << "double " << prefix << "gXMax[] = {"
           << "\n";
   for (i = 0; i < fNVariables; i++)
     outFile << (i != 0 ? ", " : "  ") << fMaxVariables(i) << std::flush;
   outFile << " };"
           << "\n"
           << "\n";
  
   // Assignment to coefficients vector.
   outFile << "// Assignment to coefficients vector."
           << "\n";
   outFile << cv_qual << "double " << prefix << "gCoefficient[] = {" << std::flush;
   for (i = 0; i < fNCoefficients; i++)
     outFile << (i != 0 ? "," : "") << "\n"
             << "  " << fCoefficients(i) << std::flush;
   outFile << "\n"
           << " };"
           << "\n"
           << "\n";
  
   // Assignment to powers vector.
   outFile << "// Assignment to powers vector."
           << "\n"
           << "// The powers are stored row-wise, that is"
           << "\n"
           << "//  p_ij = " << prefix << "gPower[i * NVariables + j];"
           << "\n";
   outFile << cv_qual << "int    " << prefix << "gPower[] = {" << std::flush;
   for (i = 0; i < fNCoefficients; i++) {
     for (j = 0; j < fNVariables; j++) {
       if (j != 0)
         outFile << std::flush << "  ";
       else
         outFile << "\n"
                 << "  ";
       outFile << fPowers[fPowerIndex[i] * fNVariables + j]
               << (i == fNCoefficients - 1 && j == fNVariables - 1 ? "" : ",") << std::flush;
     }
   }
   outFile << "\n"
           << "};"
           << "\n"
           << "\n";
  
   //
   // Finally we reach the function itself
   //
   outFile << "// "
           << "\n"
           << "// The " << (isMethod ? "method " : "function ") << "  double " << prefix << "MDF(double *x)"
           << "\n"
           << "// "
           << "\n";
   outFile << "double " << prefix << "MDF(double *x) {"
           << "\n"
           << "  double returnValue = " << prefix << "gDMean;"
           << "\n"
           << "  int    i = 0, j = 0, k = 0;"
           << "\n"
           << "  for (i = 0; i < " << prefix << "gNCoefficients ; i++) {"
           << "\n"
           << "    // Evaluate the ith term in the expansion"
           << "\n"
           << "    double term = " << prefix << "gCoefficient[i];"
           << "\n"
           << "    for (j = 0; j < " << prefix << "gNVariables; j++) {"
           << "\n"
           << "      // Evaluate the polynomial in the jth variable."
           << "\n"
           << "      int power = " << prefix << "gPower[" << prefix << "gNVariables * i + j]; "
           << "\n"
           << "      double p1 = 1, p2 = 0, p3 = 0, r = 0;"
           << "\n"
           << "      double v =  1 + 2. / (" << prefix << "gXMax[j] - " << prefix << "gXMin[j]) * (x[j] - " << prefix
           << "gXMax[j]);"
           << "\n"
           << "      // what is the power to use!"
           << "\n"
           << "      switch(power) {"
           << "\n"
           << "      case 1: r = 1; break; "
           << "\n"
           << "      case 2: r = v; break; "
           << "\n"
           << "      default: "
           << "\n"
           << "        p2 = v; "
           << "\n"
           << "        for (k = 3; k <= power; k++) { "
           << "\n"
           << "          p3 = p2 * v;"
           << "\n";
   if (fPolyType == kLegendre)
     outFile << "          p3 = ((2 * i - 3) * p2 * v - (i - 2) * p1)"
             << " / (i - 1);"
             << "\n";
   if (fPolyType == kChebyshev)
     outFile << "          p3 = 2 * v * p2 - p1; "
             << "\n";
   outFile << "          p1 = p2; p2 = p3; "
           << "\n"
           << "        }"
           << "\n"
           << "        r = p3;"
           << "\n"
           << "      }"
           << "\n"
           << "      // multiply this term by the poly in the jth var"
           << "\n"
           << "      term *= r; "
           << "\n"
           << "    }"
           << "\n"
           << "    // Add this term to the final result"
           << "\n"
           << "    returnValue += term;"
           << "\n"
           << "  }"
           << "\n"
           << "  return returnValue;"
           << "\n"
           << "}"
           << "\n"
           << "\n";
  
   // EOF
   outFile << "// EOF for " << filename << "\n";
  
   // Close the file
   outFile.close();
  
   if (fIsVerbose)
     edm::LogInfo("TMultiDimFet") << "done"
                                  << "\n";

References data-class-funcs::classname, fCoefficients, corrVsCorr::filename, fIsVerbose, fMaxVariables, fMeanQuantity, fMeanVariables, fMinVariables, fNCoefficients, fNVariables, fPolyType, fPowerIndex, fPowers, mps_fire::i, dqmiolumiharvest::j, kChebyshev, kLegendre, MillePedeFileConverter_cfg::out, L1TdeCSCTF_cfi::outFile, hcallasereventfilter2012_cfi::prefix, and pileupReCalc_HLTpaths::trunc.

Referenced by MakeCode(), and MakeMethod().

◆ operator=()

const TMultiDimFet & TMultiDimFet::operator= ( const TMultiDimFet & in )

Max value of dependent quantity

Min value of dependent quantity

SumSquare of dependent quantity

Sum of squares away from mean

Size of training sample

Size of test sample

Min angle for acepting new function

Max angle for acepting new function

Min relative error accepted

[fNVariables] maximum powers

Control parameter

[fMaxFunctions] acceptance code

max functions to study

[fNVariables] maximum powers from fit;

Max redsidual value

Min redsidual value

Row giving max residual

Row giving min residual

Sum of Square residuals

Root mean square of fit

Chi square of fit

Exit code of parameterisation

Error from parameterization

Error from test

Relative precision of param

Relative precision of test

Multi Correlation coefficient

List of histograms

Bit pattern of hisograms used

Definition at line 82 of file TMultiDimFet.cc.

                                                                   {
   if (this == &in) {
     return in;
   }
  
   fMeanQuantity = in.fMeanQuantity;  // Mean of dependent quantity
  
   fMaxQuantity = 0.0;       
   fMinQuantity = 0.0;       
   fSumSqQuantity = 0.0;     
   fSumSqAvgQuantity = 0.0;  
  
   fNVariables = in.fNVariables;  // Number of independent variables
  
   fMaxVariables.ResizeTo(in.fMaxVariables.GetLwb(), in.fMaxVariables.GetUpb());
   fMaxVariables = in.fMaxVariables;  // max value of independent variables
  
   fMinVariables.ResizeTo(in.fMinVariables.GetLwb(), in.fMinVariables.GetUpb());
   fMinVariables = in.fMinVariables;  // min value of independent variables
  
   fSampleSize = 0;      
   fTestSampleSize = 0;  
   fMinAngle = 1;        
   fMaxAngle = 0.0;      
  
   fMaxTerms = in.fMaxTerms;  // Max terms expected in final expr.
  
   fMinRelativeError = 0.0;  
  
   fMaxPowers.clear();  
   fPowerLimit = 1;     
  
   fMaxFunctions = in.fMaxFunctions;  // max number of functions
  
   fFunctionCodes.clear();  
   fMaxStudy = 0;           
  
   fMaxPowersFinal.clear();  
  
   fMaxFunctionsTimesNVariables = in.fMaxFunctionsTimesNVariables;  // fMaxFunctionsTimesNVariables
   fPowers = in.fPowers;
  
   fPowerIndex = in.fPowerIndex;  // [fMaxTerms] Index of accepted powers
  
   fMaxResidual = 0.0;    
   fMinResidual = 0.0;    
   fMaxResidualRow = 0;   
   fMinResidualRow = 0;   
   fSumSqResidual = 0.0;  
  
   fNCoefficients = in.fNCoefficients;  // Dimension of model coefficients
  
   fCoefficients.ResizeTo(in.fCoefficients.GetLwb(), in.fCoefficients.GetUpb());
   fCoefficients = in.fCoefficients;  // Vector of the final coefficients
  
   fRMS = 0.0;                   
   fChi2 = 0.0;                  
   fParameterisationCode = 0;    
   fError = 0.0;                 
   fTestError = 0.0;             
   fPrecision = 0.0;             
   fTestPrecision = 0.0;         
   fCorrelationCoeff = 0.0;      
   fTestCorrelationCoeff = 0.0;  
   fHistograms = nullptr;        
   fHistogramMask = 0;           
   //fFitter = nullptr;            //! Fit object (MINUIT)
  
   fPolyType = in.fPolyType;                // Type of polynomials to use
   fShowCorrelation = in.fShowCorrelation;  // print correlation matrix
   fIsUserFunction = in.fIsUserFunction;    // Flag for user defined function
   fIsVerbose = in.fIsVerbose;              //
   return in;

References fChi2, fCoefficients, fCorrelationCoeff, fError, fFunctionCodes, fHistogramMask, fHistograms, fIsUserFunction, fIsVerbose, fMaxAngle, fMaxFunctions, fMaxFunctionsTimesNVariables, fMaxPowers, fMaxPowersFinal, fMaxQuantity, fMaxResidual, fMaxResidualRow, fMaxStudy, fMaxTerms, fMaxVariables, fMeanQuantity, fMinAngle, fMinQuantity, fMinRelativeError, fMinResidual, fMinResidualRow, fMinVariables, fNCoefficients, fNVariables, fParameterisationCode, fPolyType, fPowerIndex, fPowerLimit, fPowers, fPrecision, fRMS, fSampleSize, fShowCorrelation, fSumSqAvgQuantity, fSumSqQuantity, fSumSqResidual, fTestCorrelationCoeff, fTestError, fTestPrecision, fTestSampleSize, and recoMuon::in.

◆ Print()

void TMultiDimFet::Print ( Option_t * option = "ps" ) const

override

Definition at line 1687 of file TMultiDimFet.cc.

                                                {
   // Print statistics etc.
   // Options are
   //   P        Parameters
   //   S        Statistics
   //   C        Coefficients
   //   R        Result of parameterisation
   //   F        Result of fit
   //   K        Correlation Matrix
   //   M        Pretty print formula
   //
   Int_t i = 0;
   Int_t j = 0;
  
   TString opt(option);
   opt.ToLower();
  
   if (opt.Contains("p")) {
     // Print basic parameters for this object
     edm::LogInfo("TMultiDimFet") << "User parameters:"
                                  << "\n"
                                  << "----------------"
                                  << "\n"
                                  << " Variables:                    " << fNVariables << "\n"
                                  << " Data points:                  " << fSampleSize << "\n"
                                  << " Max Terms:                    " << fMaxTerms << "\n"
                                  << " Power Limit Parameter:        " << fPowerLimit << "\n"
                                  << " Max functions:                " << fMaxFunctions << "\n"
                                  << " Max functions to study:       " << fMaxStudy << "\n"
                                  << " Max angle (optional):         " << fMaxAngle << "\n"
                                  << " Min angle:                    " << fMinAngle << "\n"
                                  << " Relative Error accepted:      " << fMinRelativeError << "\n"
                                  << " Maximum Powers:               " << std::flush;
     for (i = 0; i < fNVariables; i++)
       edm::LogInfo("TMultiDimFet") << " " << fMaxPowers[i] - 1 << std::flush;
     edm::LogInfo("TMultiDimFet") << "\n"
                                  << "\n"
                                  << " Parameterisation will be done using " << std::flush;
     if (fPolyType == kChebyshev)
       edm::LogInfo("TMultiDimFet") << "Chebyshev polynomials"
                                    << "\n";
     else if (fPolyType == kLegendre)
       edm::LogInfo("TMultiDimFet") << "Legendre polynomials"
                                    << "\n";
     else
       edm::LogInfo("TMultiDimFet") << "Monomials"
                                    << "\n";
     edm::LogInfo("TMultiDimFet") << "\n";
   }
  
   if (opt.Contains("s")) {
     // Print statistics for read data
     edm::LogInfo("TMultiDimFet") << "Sample statistics:"
                                  << "\n"
                                  << "------------------"
                                  << "\n"
                                  << "                 D" << std::flush;
     for (i = 0; i < fNVariables; i++)
       edm::LogInfo("TMultiDimFet") << " " << std::setw(10) << i + 1 << std::flush;
     edm::LogInfo("TMultiDimFet") << "\n"
                                  << " Max:   " << std::setw(10) << std::setprecision(7) << fMaxQuantity << std::flush;
     for (i = 0; i < fNVariables; i++)
       edm::LogInfo("TMultiDimFet") << " " << std::setw(10) << std::setprecision(4) << fMaxVariables(i) << std::flush;
     edm::LogInfo("TMultiDimFet") << "\n"
                                  << " Min:   " << std::setw(10) << std::setprecision(7) << fMinQuantity << std::flush;
     for (i = 0; i < fNVariables; i++)
       edm::LogInfo("TMultiDimFet") << " " << std::setw(10) << std::setprecision(4) << fMinVariables(i) << std::flush;
     edm::LogInfo("TMultiDimFet") << "\n"
                                  << " Mean:  " << std::setw(10) << std::setprecision(7) << fMeanQuantity << std::flush;
     for (i = 0; i < fNVariables; i++)
       edm::LogInfo("TMultiDimFet") << " " << std::setw(10) << std::setprecision(4) << fMeanVariables(i) << std::flush;
     edm::LogInfo("TMultiDimFet") << "\n"
                                  << " Function Sum Squares:         " << fSumSqQuantity << "\n"
                                  << "\n";
   }
  
   if (opt.Contains("r")) {
     edm::LogInfo("TMultiDimFet") << "Results of Parameterisation:"
                                  << "\n"
                                  << "----------------------------"
                                  << "\n"
                                  << " Total reduction of square residuals    " << fSumSqResidual << "\n"
                                  << " Relative precision obtained:           " << fPrecision << "\n"
                                  << " Error obtained:                        " << fError << "\n"
                                  << " Multiple correlation coefficient:      " << fCorrelationCoeff << "\n"
                                  << " Reduced Chi square over sample:        " << fChi2 / (fSampleSize - fNCoefficients)
                                  << "\n"
                                  << " Maximum residual value:                " << fMaxResidual << "\n"
                                  << " Minimum residual value:                " << fMinResidual << "\n"
                                  << " Estimated root mean square:            " << fRMS << "\n"
                                  << " Maximum powers used:                   " << std::flush;
     for (j = 0; j < fNVariables; j++)
       edm::LogInfo("TMultiDimFet") << fMaxPowersFinal[j] << " " << std::flush;
     edm::LogInfo("TMultiDimFet") << "\n"
                                  << " Function codes of candidate functions."
                                  << "\n"
                                  << "  1: considered,"
                                  << "  2: too little contribution,"
                                  << "  3: accepted." << std::flush;
     for (i = 0; i < fMaxFunctions; i++) {
       if (i % 60 == 0)
         edm::LogInfo("TMultiDimFet") << "\n"
                                      << " " << std::flush;
       else if (i % 10 == 0)
         edm::LogInfo("TMultiDimFet") << " " << std::flush;
       edm::LogInfo("TMultiDimFet") << fFunctionCodes[i];
     }
     edm::LogInfo("TMultiDimFet") << "\n"
                                  << " Loop over candidates stopped because " << std::flush;
     switch (fParameterisationCode) {
       case PARAM_MAXSTUDY:
         edm::LogInfo("TMultiDimFet") << "max allowed studies reached"
                                      << "\n";
         break;
       case PARAM_SEVERAL:
         edm::LogInfo("TMultiDimFet") << "all candidates considered several times"
                                      << "\n";
         break;
       case PARAM_RELERR:
         edm::LogInfo("TMultiDimFet") << "wanted relative error obtained"
                                      << "\n";
         break;
       case PARAM_MAXTERMS:
         edm::LogInfo("TMultiDimFet") << "max number of terms reached"
                                      << "\n";
         break;
       default:
         edm::LogInfo("TMultiDimFet") << "some unknown reason"
                                      << "\n";
         break;
     }
     edm::LogInfo("TMultiDimFet") << "\n";
   }
  
   if (opt.Contains("f")) {
     edm::LogInfo("TMultiDimFet") << "Results of Fit:"
                                  << "\n"
                                  << "---------------"
                                  << "\n"
                                  << " Test sample size:                      " << fTestSampleSize << "\n"
                                  << " Multiple correlation coefficient:      " << fTestCorrelationCoeff << "\n"
                                  << " Relative precision obtained:           " << fTestPrecision << "\n"
                                  << " Error obtained:                        " << fTestError << "\n"
                                  << " Reduced Chi square over sample:        " << fChi2 / (fSampleSize - fNCoefficients)
                                  << "\n"
                                  << "\n";
     /*
       if (fFitter) {
          fFitter->PrintResults(1,1);
          edm::LogInfo("TMultiDimFet") << "\n";
       }
 */
   }
  
   if (opt.Contains("c")) {
     edm::LogInfo("TMultiDimFet") << "Coefficients:"
                                  << "\n"
                                  << "-------------"
                                  << "\n"
                                  << "   #         Value        Error   Powers"
                                  << "\n"
                                  << " ---------------------------------------"
                                  << "\n";
     for (i = 0; i < fNCoefficients; i++) {
       edm::LogInfo("TMultiDimFet") << " " << std::setw(3) << i << "  " << std::setw(12) << fCoefficients(i) << "  "
                                    << std::setw(12) << fCoefficientsRMS(i) << "  " << std::flush;
       for (j = 0; j < fNVariables; j++)
         edm::LogInfo("TMultiDimFet") << " " << std::setw(3) << fPowers[fPowerIndex[i] * fNVariables + j] - 1
                                      << std::flush;
       edm::LogInfo("TMultiDimFet") << "\n";
     }
     edm::LogInfo("TMultiDimFet") << "\n";
   }
   if (opt.Contains("k") && fCorrelationMatrix.IsValid()) {
     edm::LogInfo("TMultiDimFet") << "Correlation Matrix:"
                                  << "\n"
                                  << "-------------------";
     fCorrelationMatrix.Print();
   }
  
   if (opt.Contains("m")) {
     edm::LogInfo("TMultiDimFet") << std::setprecision(25);
     edm::LogInfo("TMultiDimFet") << "Parameterization:"
                                  << "\n"
                                  << "-----------------"
                                  << "\n"
                                  << "  Normalised variables: "
                                  << "\n";
     for (i = 0; i < fNVariables; i++)
       edm::LogInfo("TMultiDimFet") << "\ty" << i << "\t:= 1 + 2 * (x" << i << " - " << fMaxVariables(i) << ") / ("
                                    << fMaxVariables(i) << " - " << fMinVariables(i) << ")"
                                    << "\n";
     edm::LogInfo("TMultiDimFet") << "\n"
                                  << "  f[";
     for (i = 0; i < fNVariables; i++) {
       edm::LogInfo("TMultiDimFet") << "y" << i;
       if (i != fNVariables - 1)
         edm::LogInfo("TMultiDimFet") << ", ";
     }
     edm::LogInfo("TMultiDimFet") << "] := ";
     for (Int_t i = 0; i < fNCoefficients; i++) {
       if (i != 0)
         edm::LogInfo("TMultiDimFet") << " " << (fCoefficients(i) < 0 ? "- " : "+ ") << TMath::Abs(fCoefficients(i));
       else
         edm::LogInfo("TMultiDimFet") << fCoefficients(i);
       for (Int_t j = 0; j < fNVariables; j++) {
         Int_t p = fPowers[fPowerIndex[i] * fNVariables + j];
         switch (p) {
           case 1:
             break;
           case 2:
             edm::LogInfo("TMultiDimFet") << " * y" << j;
             break;
           default:
             switch (fPolyType) {
               case kLegendre:
                 edm::LogInfo("TMultiDimFet") << " * L" << p - 1 << "(y" << j << ")";
                 break;
               case kChebyshev:
                 edm::LogInfo("TMultiDimFet") << " * C" << p - 1 << "(y" << j << ")";
                 break;
               default:
                 edm::LogInfo("TMultiDimFet") << " * y" << j << "^" << p - 1;
                 break;
             }
         }
       }
     }
     edm::LogInfo("TMultiDimFet") << "\n";
   }

References Abs(), fChi2, fCoefficients, fCoefficientsRMS, fCorrelationCoeff, fCorrelationMatrix, fError, fFunctionCodes, fMaxAngle, fMaxFunctions, fMaxPowers, fMaxPowersFinal, fMaxQuantity, fMaxResidual, fMaxStudy, fMaxTerms, fMaxVariables, fMeanQuantity, fMeanVariables, fMinAngle, fMinQuantity, fMinRelativeError, fMinResidual, fMinVariables, fNCoefficients, fNVariables, fParameterisationCode, fPolyType, fPowerIndex, fPowerLimit, fPowers, fPrecision, fRMS, fSampleSize, fSumSqQuantity, fSumSqResidual, fTestCorrelationCoeff, fTestError, fTestPrecision, fTestSampleSize, mps_fire::i, dqmiolumiharvest::j, kChebyshev, kLegendre, runTheMatrix::opt, fileinputsource_cfi::option, AlCaHLTBitMon_ParallelJobs::p, PARAM_MAXSTUDY, PARAM_MAXTERMS, PARAM_RELERR, and PARAM_SEVERAL.

◆ PrintPolynomialsSpecial()

void TMultiDimFet::PrintPolynomialsSpecial ( Option_t * option = "m" ) const

virtual

Definition at line 1920 of file TMultiDimFet.cc.

                                                                  {
   //   M        Pretty print formula
   //
   Int_t i = 0;
   //   Int_t j = 0;
  
   TString opt(option);
   opt.ToLower();
  
   if (opt.Contains("m")) {
     edm::LogInfo("TMultiDimFet") << std::setprecision(25);
     edm::LogInfo("TMultiDimFet") << "Parameterization:"
                                  << "\n"
                                  << "-----------------"
                                  << "\n"
                                  << "  Normalised variables: "
                                  << "\n";
     for (i = 0; i < fNVariables; i++)
       edm::LogInfo("TMultiDimFet") << "\tdouble y" << i << "\t=1+2*(x" << i << "-" << fMaxVariables(i) << ")/("
                                    << fMaxVariables(i) << "-" << fMinVariables(i) << ");"
                                    << "\n";
     edm::LogInfo("TMultiDimFet") << "\n"
                                  << "  f[";
     for (i = 0; i < fNVariables; i++) {
       edm::LogInfo("TMultiDimFet") << "y" << i;
       if (i != fNVariables - 1)
         edm::LogInfo("TMultiDimFet") << ", ";
     }
     edm::LogInfo("TMultiDimFet") << "] := " << fMeanQuantity << " + ";
     for (Int_t i = 0; i < fNCoefficients; i++) {
       if (i != 0)
         edm::LogInfo("TMultiDimFet") << " " << (fCoefficients(i) < 0 ? "-" : "+") << TMath::Abs(fCoefficients(i));
       else
         edm::LogInfo("TMultiDimFet") << fCoefficients(i);
       for (Int_t j = 0; j < fNVariables; j++) {
         Int_t p = fPowers[fPowerIndex[i] * fNVariables + j];
         switch (p) {
           case 1:
             break;
           case 2:
             edm::LogInfo("TMultiDimFet") << "*y" << j;
             break;
           default:
             switch (fPolyType) {
               case kLegendre:
                 edm::LogInfo("TMultiDimFet") << "*Leg(" << p - 1 << ",y" << j << ")";
                 break;
               case kChebyshev:
                 edm::LogInfo("TMultiDimFet") << "*C" << p - 1 << "(y" << j << ")";
                 break;
               default:
                 edm::LogInfo("TMultiDimFet") << "*y" << j << "**" << p - 1;
                 break;
             }
         }
       }
       edm::LogInfo("TMultiDimFet") << "\n";
     }
     edm::LogInfo("TMultiDimFet") << "\n";
   }

References Abs(), fCoefficients, fMaxVariables, fMeanQuantity, fMinVariables, fNCoefficients, fNVariables, fPolyType, fPowerIndex, fPowers, mps_fire::i, dqmiolumiharvest::j, kChebyshev, kLegendre, runTheMatrix::opt, fileinputsource_cfi::option, and AlCaHLTBitMon_ParallelJobs::p.

◆ ReducePolynomial()

void TMultiDimFet::ReducePolynomial ( double error )

Definition at line 465 of file TMultiDimFet.cc.

                                                 {
   if (error == 0.0)
     return;
   else {
     ZeroDoubiousCoefficients(error);
   }

References relativeConstraints::error, and ZeroDoubiousCoefficients().

Referenced by FindParameterization().

◆ Select()

Bool_t TMultiDimFet::Select ( const Int_t * iv )

protectedvirtual

Definition at line 1983 of file TMultiDimFet.cc.

                                          {
   // Selection method. User can override this method for specialized
   // selection of acceptable functions in fit. Default is to select
   // all. This message is sent during the build-up of the function
   // candidates table once for each set of powers in
   // variables. Notice, that the argument array contains the powers
   // PLUS ONE. For example, to De select the function
   //     f = x1^2 * x2^4 * x3^5,
   // this method should return kFALSE if given the argument
   //     { 3, 4, 6 }
   return kTRUE;

Referenced by MakeCandidates().

◆ SetMaxAngle()

void TMultiDimFet::SetMaxAngle ( Double_t angle = 0 )

Definition at line 1997 of file TMultiDimFet.cc.

                                            {
   // Set the max angle (in degrees) between the initial data vector to
   // be fitted, and the new candidate function to be included in the
   // fit.  By default it is 0, which automatically chooses another
   // selection criteria. See also
   // Begin_Html<a href="#TMultiDimFet:description">class description</a>End_Html
   if (ang >= 90 || ang < 0) {
     Warning("SetMaxAngle", "angle must be in [0,90)");
     return;
   }
  
   fMaxAngle = ang;

References fMaxAngle.

Referenced by LHCOpticsApproximator::SetDefaultAproximatorSettings().

◆ SetMaxFunctions()

void TMultiDimFet::SetMaxFunctions ( Int_t n )

inline

Definition at line 211 of file TMultiDimFet.h.

Referenced by LHCOpticsApproximator::SetDefaultAproximatorSettings().

◆ SetMaxPowers()

void TMultiDimFet::SetMaxPowers ( const Int_t * powers )

Definition at line 2055 of file TMultiDimFet.cc.

                                                    {
   // Set the maximum power to be considered in the fit for each
   // variable. See also
   // Begin_Html<a href="#TMultiDimFet:description">class description</a>End_Html
   if (!powers)
     return;
  
   for (Int_t i = 0; i < fNVariables; i++)
     fMaxPowers[i] = powers[i] + 1;

References fMaxPowers, fNVariables, and mps_fire::i.

Referenced by LHCOpticsApproximator::SetDefaultAproximatorSettings().

◆ SetMaxStudy()

void TMultiDimFet::SetMaxStudy ( Int_t n )

inline

Definition at line 213 of file TMultiDimFet.h.

Referenced by LHCOpticsApproximator::SetDefaultAproximatorSettings().

◆ SetMaxTerms()

void TMultiDimFet::SetMaxTerms ( Int_t terms )

inline

Definition at line 214 of file TMultiDimFet.h.

Referenced by LHCOpticsApproximator::SetDefaultAproximatorSettings().

◆ SetMinAngle()

void TMultiDimFet::SetMinAngle ( Double_t angle = 1 )

Definition at line 2012 of file TMultiDimFet.cc.

                                            {
   // Set the min angle (in degrees) between a new candidate function
   // and the subspace spanned by the previously accepted
   // functions. See also
   // Begin_Html<a href="#TMultiDimFet:description">class description</a>End_Html
   if (ang > 90 || ang <= 0) {
     Warning("SetMinAngle", "angle must be in [0,90)");
     return;
   }
  
   fMinAngle = ang;

References fMinAngle.

Referenced by LHCOpticsApproximator::SetDefaultAproximatorSettings().

◆ SetMinRelativeError()

void TMultiDimFet::SetMinRelativeError ( Double_t error )

Definition at line 2067 of file TMultiDimFet.cc.

                                                      {
   // Set the acceptable relative error for when sum of square
   // residuals is considered minimized. For a full account, refer to
   // the
   // Begin_Html<a href="#TMultiDimFet:description">class description</a>End_Html
   fMinRelativeError = error;

References relativeConstraints::error, and fMinRelativeError.

Referenced by LHCOpticsApproximator::SetDefaultAproximatorSettings().

◆ SetPowerLimit()

void TMultiDimFet::SetPowerLimit ( Double_t limit = 1e-3 )

Definition at line 2046 of file TMultiDimFet.cc.

                                                {
   // Set the user parameter for the function selection. The bigger the
   // limit, the more functions are used. The meaning of this variable
   // is defined in the
   // Begin_Html<a href="#TMultiDimFet:description">class description</a>End_Html
   fPowerLimit = limit;

References fPowerLimit, and remoteMonitoring_LED_IterMethod_cfg::limit.

Referenced by LHCOpticsApproximator::SetDefaultAproximatorSettings().

◆ SetPowers()

void TMultiDimFet::SetPowers	(	const Int_t *	powers,
		Int_t	terms
	)

virtual

Definition at line 2026 of file TMultiDimFet.cc.

                                                              {
   // Define a user function. The input array must be of the form
   // (p11, ..., p1N, ... ,pL1, ..., pLN)
   // Where N is the dimension of the data sample, L is the number of
   // terms (given in terms) and the first number, labels the term, the
   // second the variable.  More information is given in the
   // Begin_Html<a href="#TMultiDimFet:description">class description</a>End_Html
   fIsUserFunction = kTRUE;
   fMaxFunctions = terms;
   fMaxTerms = terms;
   fMaxStudy = terms;
   fMaxFunctionsTimesNVariables = fMaxFunctions * fNVariables;
   fPowers.resize(fMaxFunctions * fNVariables);
   Int_t i, j;
   for (i = 0; i < fMaxFunctions; i++)
     for (j = 0; j < fNVariables; j++)
       fPowers[i * fNVariables + j] = powers[i * fNVariables + j] + 1;

References fIsUserFunction, fMaxFunctions, fMaxFunctionsTimesNVariables, fMaxStudy, fMaxTerms, fNVariables, fPowers, mps_fire::i, and dqmiolumiharvest::j.

Referenced by LHCOpticsApproximator::SetTermsManually().

◆ TestFunction()

Bool_t TMultiDimFet::TestFunction	(	Double_t	squareResidual,
		Double_t	dResidur
	)

protectedvirtual

Definition at line 2076 of file TMultiDimFet.cc.

                                                                             {
   // PRIVATE METHOD:
   // Test whether the currently considered function contributes to the
   // fit. See also
   // Begin_Html<a href="#TMultiDimFet:description">class description</a>End_Html
  
   if (fNCoefficients != 0) {
     // Now for the second test:
     if (fMaxAngle == 0) {
       // If the user hasn't supplied a max angle do the test as,
       if (dResidur < squareResidual / (fMaxTerms - fNCoefficients + 1 + 1E-10)) {
         return kFALSE;
       }
     } else {
       // If the user has provided a max angle, test if the calculated
       // angle is less then the max angle.
       if (TMath::Sqrt(dResidur / fSumSqAvgQuantity) < TMath::Cos(fMaxAngle * DEGRAD)) {
         return kFALSE;
       }
     }
   }
   // If we get here, the function is OK
   return kTRUE;

References DEGRAD, fMaxAngle, fMaxTerms, fNCoefficients, and fSumSqAvgQuantity.

Referenced by MakeParameterization().

◆ ZeroDoubiousCoefficients()

void TMultiDimFet::ZeroDoubiousCoefficients ( double error )

Definition at line 473 of file TMultiDimFet.cc.

                                                         {
   typedef std::multimap<double, int> cmt;
   cmt m;
  
   for (int i = 0; i < fNCoefficients; i++) {
     m.insert(std::pair<double, int>(TMath::Abs(fCoefficients(i)), i));
   }
  
   double del_error_abs = 0;
   int deleted_terms_count = 0;
  
   for (cmt::iterator it = m.begin(); it != m.end() && del_error_abs < error; ++it) {
     if (TMath::Abs(it->first) + del_error_abs < error) {
       fCoefficients(it->second) = 0.0;
       del_error_abs = TMath::Abs(it->first) + del_error_abs;
       deleted_terms_count++;
     } else
       break;
   }
  
   int fNCoefficients_new = fNCoefficients - deleted_terms_count;
   TVectorD fCoefficients_new(fNCoefficients_new);
   std::vector<Int_t> fPowerIndex_new;
  
   int ind = 0;
   for (int i = 0; i < fNCoefficients; i++) {
     if (fCoefficients(i) != 0.0) {
       fCoefficients_new(ind) = fCoefficients(i);
       fPowerIndex_new.push_back(fPowerIndex[i]);
       ind++;
     }
   }
   fNCoefficients = fNCoefficients_new;
   fCoefficients.ResizeTo(fNCoefficients);
   fCoefficients = fCoefficients_new;
   fPowerIndex = fPowerIndex_new;
   edm::LogInfo("TMultiDimFet") << deleted_terms_count << " terms removed"
                                << "\n";

References Abs(), relativeConstraints::error, fCoefficients, fNCoefficients, fPowerIndex, mps_fire::i, and visualization-live-secondInstance_cfg::m.

Referenced by ReducePolynomial().

Member Data Documentation

◆ fChi2

Double_t TMultiDimFet::fChi2

protected

Root mean square of fit.

Definition at line 104 of file TMultiDimFet.h.

Referenced by MakeChi2(), MakeCoefficientErrors(), operator=(), and Print().

◆ fCoefficients

TVectorD TMultiDimFet::fCoefficients

protected

Model matrix.

Definition at line 101 of file TMultiDimFet.h.

Referenced by Clear(), Eval(), MakeCoefficientErrors(), MakeCoefficients(), MakeRealCode(), operator=(), Print(), PrintPolynomialsSpecial(), and ZeroDoubiousCoefficients().

◆ fCoefficientsRMS

TVectorD TMultiDimFet::fCoefficientsRMS

protected

Definition at line 102 of file TMultiDimFet.h.

Referenced by Clear(), MakeCoefficientErrors(), and Print().

◆ fCorrelationCoeff

Double_t TMultiDimFet::fCorrelationCoeff

protected

Relative precision of test.

Definition at line 111 of file TMultiDimFet.h.

Referenced by MakeCoefficients(), operator=(), and Print().

◆ fCorrelationMatrix

TMatrixD TMultiDimFet::fCorrelationMatrix

protected

Multi Correlation coefficient.

Definition at line 112 of file TMultiDimFet.h.

Referenced by Clear(), MakeCorrelation(), and Print().

◆ fError

Double_t TMultiDimFet::fError

protected

Exit code of parameterisation.

Definition at line 107 of file TMultiDimFet.h.

Referenced by Clear(), MakeParameterization(), operator=(), Print(), and TMultiDimFet().

◆ fFunctionCodes

std::vector<Int_t> TMultiDimFet::fFunctionCodes

protected

Definition at line 80 of file TMultiDimFet.h.

Referenced by MakeParameterization(), operator=(), and Print().

◆ fFunctions

TMatrixD TMultiDimFet::fFunctions

protected

Control parameter.

Definition at line 78 of file TMultiDimFet.h.

Referenced by Clear(), MakeCoefficientErrors(), MakeCoefficients(), MakeGramSchmidt(), and MakeParameterization().

◆ fHistogramMask

Byte_t TMultiDimFet::fHistogramMask

protected

List of histograms.

Definition at line 116 of file TMultiDimFet.h.

Referenced by MakeCoefficients(), MakeHistograms(), MakeNormalized(), operator=(), and TMultiDimFet().

◆ fHistograms

TList* TMultiDimFet::fHistograms

protected

Multi Correlation coefficient.

Definition at line 115 of file TMultiDimFet.h.

Referenced by Clear(), MakeCoefficients(), MakeHistograms(), MakeNormalized(), operator=(), TMultiDimFet(), and ~TMultiDimFet().

◆ fIsUserFunction

Bool_t TMultiDimFet::fIsUserFunction

protected

Definition at line 122 of file TMultiDimFet.h.

Referenced by Clear(), MakeCandidates(), MakeGramSchmidt(), MakeParameterization(), operator=(), SetPowers(), and TMultiDimFet().

◆ fIsVerbose

Bool_t TMultiDimFet::fIsVerbose

protected

Definition at line 123 of file TMultiDimFet.h.

Referenced by MakeParameterization(), MakeRealCode(), operator=(), and TMultiDimFet().

◆ fMaxAngle

Double_t TMultiDimFet::fMaxAngle

protected

Min angle for acepting new function.

Definition at line 72 of file TMultiDimFet.h.

Referenced by Clear(), MakeParameterization(), operator=(), Print(), SetMaxAngle(), TestFunction(), and TMultiDimFet().

◆ fMaxFunctions

Int_t TMultiDimFet::fMaxFunctions

protected

Functions evaluated over sample.

Definition at line 79 of file TMultiDimFet.h.

Referenced by Clear(), GetChi2(), MakeCandidates(), MakeParameterization(), operator=(), Print(), SetPowers(), and TMultiDimFet().

◆ fMaxFunctionsTimesNVariables

Int_t TMultiDimFet::fMaxFunctionsTimesNVariables

protected

maximum powers from fit, ex-array

Definition at line 87 of file TMultiDimFet.h.

Referenced by Clear(), MakeCandidates(), operator=(), SetPowers(), and TMultiDimFet().

◆ fMaxPowers

std::vector<Int_t> TMultiDimFet::fMaxPowers

protected

Min relative error accepted.

Definition at line 75 of file TMultiDimFet.h.

Referenced by Clear(), EvalControl(), GetCorrelationMatrix(), MakeCandidates(), operator=(), Print(), SetMaxPowers(), and TMultiDimFet().

◆ fMaxPowersFinal

std::vector<Int_t> TMultiDimFet::fMaxPowersFinal

protected

Norm of the evaluated functions.

Definition at line 86 of file TMultiDimFet.h.

Referenced by Clear(), MakeParameterization(), operator=(), Print(), and TMultiDimFet().

◆ fMaxQuantity

Double_t TMultiDimFet::fMaxQuantity

protected

Definition at line 52 of file TMultiDimFet.h.

Referenced by AddRow(), Clear(), GetCoefficients(), MakeHistograms(), MakeNormalized(), operator=(), Print(), and TMultiDimFet().

◆ fMaxResidual

Double_t TMultiDimFet::fMaxResidual

protected

Vector of the final residuals.

Definition at line 92 of file TMultiDimFet.h.

Referenced by Clear(), GetNVariables(), MakeCoefficients(), operator=(), and Print().

◆ fMaxResidualRow

Int_t TMultiDimFet::fMaxResidualRow

protected

Min redsidual value.

Definition at line 94 of file TMultiDimFet.h.

Referenced by Clear(), GetPolyType(), MakeCoefficients(), and operator=().

◆ fMaxStudy

Int_t TMultiDimFet::fMaxStudy

protected

acceptance code, ex-array

Definition at line 81 of file TMultiDimFet.h.

Referenced by Clear(), GetError(), MakeParameterization(), operator=(), Print(), and SetPowers().

◆ fMaxTerms

Int_t TMultiDimFet::fMaxTerms

protected

Max angle for acepting new function.

Definition at line 73 of file TMultiDimFet.h.

Referenced by Clear(), GetFunctionCodes(), MakeParameterization(), operator=(), Print(), SetPowers(), and TestFunction().

◆ fMaxVariables

TVectorD TMultiDimFet::fMaxVariables

protected

mean value of independent variables

Definition at line 60 of file TMultiDimFet.h.

Referenced by AddRow(), AddTestRow(), Clear(), Eval(), GetFunctions(), MakeHistograms(), MakeNormalized(), MakeRealCode(), operator=(), Print(), PrintPolynomialsSpecial(), and TMultiDimFet().

◆ fMeanQuantity

Double_t TMultiDimFet::fMeanQuantity

protected

Training sample, error in quantity.

Definition at line 51 of file TMultiDimFet.h.

Referenced by AddRow(), Clear(), Eval(), GetHistograms(), MakeHistograms(), MakeNormalized(), MakeRealCode(), operator=(), Print(), PrintPolynomialsSpecial(), and TMultiDimFet().

◆ fMeanVariables

TVectorD TMultiDimFet::fMeanVariables

protected

Definition at line 59 of file TMultiDimFet.h.

Referenced by AddRow(), Clear(), GetMaxAngle(), MakeCorrelation(), MakeNormalized(), MakeRealCode(), and Print().

◆ fMinAngle

Double_t TMultiDimFet::fMinAngle

protected

Size of test sample.

Definition at line 71 of file TMultiDimFet.h.

Referenced by Clear(), GetMaxFunctions(), MakeGramSchmidt(), operator=(), Print(), SetMinAngle(), and TMultiDimFet().

◆ fMinQuantity

Double_t TMultiDimFet::fMinQuantity

protected

Max value of dependent quantity.

Definition at line 53 of file TMultiDimFet.h.

Referenced by AddRow(), Clear(), GetMaxPowers(), MakeHistograms(), MakeNormalized(), operator=(), Print(), and TMultiDimFet().

◆ fMinRelativeError

Double_t TMultiDimFet::fMinRelativeError

protected

Definition at line 74 of file TMultiDimFet.h.

Referenced by Clear(), GetMaxQuantity(), MakeParameterization(), operator=(), Print(), SetMinRelativeError(), and TMultiDimFet().

◆ fMinResidual

Double_t TMultiDimFet::fMinResidual

protected

Max redsidual value.

Definition at line 93 of file TMultiDimFet.h.

Referenced by Clear(), GetNCoefficients(), MakeCoefficients(), operator=(), and Print().

◆ fMinResidualRow

Int_t TMultiDimFet::fMinResidualRow

protected

Row giving max residual.

Definition at line 95 of file TMultiDimFet.h.

Referenced by Clear(), GetPowerIndex(), MakeCoefficients(), and operator=().

◆ fMinVariables

TVectorD TMultiDimFet::fMinVariables

protected

Definition at line 61 of file TMultiDimFet.h.

Referenced by AddRow(), AddTestRow(), Clear(), Eval(), GetMaxStudy(), MakeHistograms(), MakeNormalized(), MakeRealCode(), operator=(), Print(), PrintPolynomialsSpecial(), and TMultiDimFet().

◆ fNCoefficients

Int_t TMultiDimFet::fNCoefficients

protected

Sum of Square residuals.

Definition at line 98 of file TMultiDimFet.h.

Referenced by Clear(), Eval(), GetMaxVariables(), MakeCoefficientErrors(), MakeCoefficients(), MakeGramSchmidt(), MakeParameterization(), MakeRealCode(), operator=(), Print(), PrintPolynomialsSpecial(), TestFunction(), and ZeroDoubiousCoefficients().

◆ fNVariables

Int_t TMultiDimFet::fNVariables

protected

Training sample, independent variables.

Definition at line 58 of file TMultiDimFet.h.

Referenced by AddRow(), AddTestRow(), Clear(), Eval(), EvalControl(), GetMaxTerms(), MakeCandidates(), MakeChi2(), MakeCoefficients(), MakeCorrelation(), MakeGramSchmidt(), MakeHistograms(), MakeNormalized(), MakeParameterization(), MakeRealCode(), operator=(), Print(), PrintPolynomialsSpecial(), SetMaxPowers(), SetPowers(), and TMultiDimFet().

◆ fOrthCoefficients

TVectorD TMultiDimFet::fOrthCoefficients

protected

Definition at line 99 of file TMultiDimFet.h.

Referenced by Clear(), MakeCoefficients(), MakeGramSchmidt(), and MakeParameterization().

◆ fOrthCurvatureMatrix

TMatrixD TMultiDimFet::fOrthCurvatureMatrix

protected

The model coefficients.

Definition at line 100 of file TMultiDimFet.h.

Referenced by Clear(), MakeCoefficients(), MakeGramSchmidt(), and MakeParameterization().

◆ fOrthFunctionNorms

TVectorD TMultiDimFet::fOrthFunctionNorms

protected

As above, but orthogonalised.

Definition at line 84 of file TMultiDimFet.h.

Referenced by Clear(), MakeGramSchmidt(), and MakeParameterization().

◆ fOrthFunctions

TMatrixD TMultiDimFet::fOrthFunctions

protected

max functions to study

Definition at line 83 of file TMultiDimFet.h.

Referenced by Clear(), MakeGramSchmidt(), and MakeParameterization().

◆ fParameterisationCode

Int_t TMultiDimFet::fParameterisationCode

protected

Chi square of fit.

Definition at line 105 of file TMultiDimFet.h.

Referenced by MakeParameterization(), operator=(), Print(), and TMultiDimFet().

◆ fPolyType

EMDFPolyType TMultiDimFet::fPolyType

protected

Bit pattern of hisograms used.

Definition at line 120 of file TMultiDimFet.h.

Referenced by Clear(), EvalFactor(), GetMeanQuantity(), MakeRealCode(), operator=(), Print(), PrintPolynomialsSpecial(), and TMultiDimFet().

◆ fPowerIndex

std::vector<Int_t> TMultiDimFet::fPowerIndex

protected

Definition at line 89 of file TMultiDimFet.h.

Referenced by Eval(), GetMeanVariables(), MakeParameterization(), MakeRealCode(), operator=(), Print(), PrintPolynomialsSpecial(), and ZeroDoubiousCoefficients().

◆ fPowerLimit

Double_t TMultiDimFet::fPowerLimit

protected

maximum powers, ex-array

Definition at line 76 of file TMultiDimFet.h.

Referenced by Clear(), GetMinAngle(), MakeCandidates(), operator=(), Print(), SetPowerLimit(), and TMultiDimFet().

◆ fPowers

std::vector<Int_t> TMultiDimFet::fPowers

protected

Definition at line 88 of file TMultiDimFet.h.

Referenced by Clear(), Eval(), GetMinQuantity(), MakeCandidates(), MakeGramSchmidt(), MakeParameterization(), MakeRealCode(), operator=(), Print(), PrintPolynomialsSpecial(), and SetPowers().

◆ fPrecision

Double_t TMultiDimFet::fPrecision

protected

Error from test.

Definition at line 109 of file TMultiDimFet.h.

Referenced by Clear(), GetMinRelativeError(), MakeCoefficients(), operator=(), Print(), and TMultiDimFet().

◆ fQuantity

TVectorD TMultiDimFet::fQuantity

protected

Definition at line 49 of file TMultiDimFet.h.

Referenced by AddRow(), Clear(), GetMinVariables(), MakeCoefficientErrors(), MakeCoefficients(), MakeCorrelation(), MakeGramSchmidt(), and MakeNormalized().

◆ fResiduals

TVectorD TMultiDimFet::fResiduals

protected

Definition at line 91 of file TMultiDimFet.h.

Referenced by Clear(), and MakeCoefficients().

◆ fRMS

Double_t TMultiDimFet::fRMS

protected

Vector of RMS of coefficients.

Definition at line 103 of file TMultiDimFet.h.

Referenced by Clear(), GetPowers(), MakeParameterization(), operator=(), and Print().

◆ fSampleSize

Int_t TMultiDimFet::fSampleSize

protected

Definition at line 63 of file TMultiDimFet.h.

Referenced by AddRow(), Clear(), GetPrecision(), MakeCoefficientErrors(), MakeCoefficients(), MakeCorrelation(), MakeGramSchmidt(), MakeNormalized(), MakeParameterization(), operator=(), Print(), and TMultiDimFet().

◆ fShowCorrelation

Bool_t TMultiDimFet::fShowCorrelation

protected

Definition at line 121 of file TMultiDimFet.h.

Referenced by Clear(), MakeCorrelation(), operator=(), and TMultiDimFet().

◆ fSqError

TVectorD TMultiDimFet::fSqError

protected

Training sample, dependent quantity.

Definition at line 50 of file TMultiDimFet.h.

Referenced by AddRow(), Clear(), GetQuantity(), and MakeCoefficientErrors().

◆ fSumSqAvgQuantity

Double_t TMultiDimFet::fSumSqAvgQuantity

protected

SumSquare of dependent quantity.

Definition at line 55 of file TMultiDimFet.h.

Referenced by Clear(), GetResidualMax(), MakeCoefficients(), MakeNormalized(), MakeParameterization(), operator=(), TestFunction(), and TMultiDimFet().

◆ fSumSqQuantity

Double_t TMultiDimFet::fSumSqQuantity

protected

Min value of dependent quantity.

Definition at line 54 of file TMultiDimFet.h.

Referenced by AddRow(), Clear(), GetResidualMin(), MakeCoefficients(), operator=(), Print(), and TMultiDimFet().

◆ fSumSqResidual

Double_t TMultiDimFet::fSumSqResidual

protected

Row giving min residual.

Definition at line 96 of file TMultiDimFet.h.

Referenced by Clear(), GetPowerLimit(), MakeCoefficients(), MakeParameterization(), operator=(), and Print().

◆ fTestCorrelationCoeff

Double_t TMultiDimFet::fTestCorrelationCoeff

protected

Correlation matrix.

Definition at line 113 of file TMultiDimFet.h.

Referenced by operator=(), and Print().

◆ fTestError

Double_t TMultiDimFet::fTestError

protected

Error from parameterization.

Definition at line 108 of file TMultiDimFet.h.

Referenced by Clear(), GetResidualMaxRow(), operator=(), Print(), and TMultiDimFet().

◆ fTestPrecision

Double_t TMultiDimFet::fTestPrecision

protected

Relative precision of param.

Definition at line 110 of file TMultiDimFet.h.

Referenced by Clear(), GetResidualMinRow(), operator=(), Print(), and TMultiDimFet().

◆ fTestQuantity

TVectorD TMultiDimFet::fTestQuantity

protected

Size of training sample.

Definition at line 65 of file TMultiDimFet.h.

Referenced by AddTestRow(), Clear(), GetResidualSumSq(), and MakeChi2().

◆ fTestSampleSize

Int_t TMultiDimFet::fTestSampleSize

protected

Test sample, independent variables.

Definition at line 69 of file TMultiDimFet.h.

Referenced by AddTestRow(), Clear(), GetRMS(), MakeChi2(), operator=(), Print(), and TMultiDimFet().

◆ fTestSqError

TVectorD TMultiDimFet::fTestSqError

protected

Test sample, dependent quantity.

Definition at line 66 of file TMultiDimFet.h.

Referenced by AddTestRow(), Clear(), GetSampleSize(), and MakeChi2().

◆ fTestVariables

TVectorD TMultiDimFet::fTestVariables

protected

Test sample, Error in quantity.

Definition at line 67 of file TMultiDimFet.h.

Referenced by AddTestRow(), Clear(), GetSqError(), and MakeChi2().

◆ fVariables

TVectorD TMultiDimFet::fVariables

protected

Sum of squares away from mean.

Definition at line 57 of file TMultiDimFet.h.

Referenced by AddRow(), Clear(), GetSumSqAvgQuantity(), MakeCoefficients(), MakeCorrelation(), MakeGramSchmidt(), and MakeNormalized().

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

◆ EMDFPolyType

Constructor & Destructor Documentation

◆ TMultiDimFet() [1/2]

◆ TMultiDimFet() [2/2]

◆ ~TMultiDimFet()

Member Function Documentation

◆ AddRow()

◆ AddTestRow()

◆ Clear()

◆ Eval()

◆ EvalControl()

◆ EvalFactor()

◆ FindParameterization()

◆ GetChi2()

◆ GetCoefficients()

◆ GetCorrelationMatrix()

◆ GetError()

◆ GetFunctionCodes()

◆ GetFunctions()

◆ GetHistograms()

◆ GetMaxAngle()

◆ GetMaxFunctions()

◆ GetMaxPowers()

◆ GetMaxQuantity()

◆ GetMaxStudy()

◆ GetMaxTerms()

◆ GetMaxVariables()

◆ GetMeanQuantity()

◆ GetMeanVariables()

◆ GetMinAngle()

◆ GetMinQuantity()

◆ GetMinRelativeError()

◆ GetMinVariables()

◆ GetNCoefficients()

◆ GetNVariables()

◆ GetPolyType()

◆ GetPowerIndex()

◆ GetPowerLimit()

◆ GetPowers()

◆ GetPrecision()

◆ GetQuantity()

◆ GetResidualMax()

◆ GetResidualMaxRow()

◆ GetResidualMin()

◆ GetResidualMinRow()

◆ GetResidualSumSq()

◆ GetRMS()

◆ GetSampleSize()

◆ GetSqError()

◆ GetSumSqAvgQuantity()

◆ GetSumSqQuantity()

◆ GetTestError()

◆ GetTestPrecision()

◆ GetTestQuantity()

◆ GetTestSampleSize()

◆ GetTestSqError()

◆ GetTestVariables()

◆ GetVariables()

◆ IsFolder()

◆ MakeCandidates()

◆ MakeChi2()

◆ MakeCode()

◆ MakeCoefficientErrors()

◆ MakeCoefficients()

◆ MakeCorrelation()

◆ MakeGramSchmidt()

◆ MakeHistograms()

◆ MakeMethod()

◆ MakeNormalized()

◆ MakeParameterization()

◆ MakeRealCode()

◆ operator=()

◆ Print()

◆ PrintPolynomialsSpecial()