TMultiDimFet Class Reference

#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 36 of file TMultiDimFet.h.

Member Enumeration Documentation

EMDFPolyType

enum TMultiDimFet::EMDFPolyType

Enumerator
kMonomials
kChebyshev
kLegendre

Definition at line 38 of file TMultiDimFet.h.

{ kMonomials, kChebyshev, kLegendre };

Constructor & Destructor Documentation

TMultiDimFet() [1/2]

TMultiDimFet::TMultiDimFet

(

)

Definition at line 51 of file TMultiDimFet.cc.

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

                           {
  // 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;
}

TMultiDimFet() [2/2]

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

Definition at line 159 of file TMultiDimFet.cc.

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.

    : 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;
}

~TMultiDimFet()

TMultiDimFet::~TMultiDimFet ( )

override

Definition at line 229 of file TMultiDimFet.cc.

References fHistograms.

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

Member Function Documentation

AddRow()

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

virtual

Definition at line 236 of file TMultiDimFet.cc.

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().

                                                                   {
  // 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];
  }
}

AddTestRow()

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

virtual

Definition at line 312 of file TMultiDimFet.cc.

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

                                                                       {
  // 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));
  }
}

Clear()

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

override

Definition at line 361 of file TMultiDimFet.cc.

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.

                                         {
  // 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;
}

Eval()

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

virtual

Definition at line 442 of file TMultiDimFet.cc.

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().

                                                                          {
  // 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;
}

EvalControl()

Double_t TMultiDimFet::EvalControl ( const Int_t *  powers )

protectedvirtual

Definition at line 515 of file TMultiDimFet.cc.

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

Referenced by MakeCandidates(), and MakeParameterization().

                                                  {
  // 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;
}

EvalFactor()

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

protectedvirtual

Definition at line 528 of file TMultiDimFet.cc.

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

Referenced by Eval(), and MakeGramSchmidt().

                                                           {
  // 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;
}

FindParameterization()

void TMultiDimFet::FindParameterization ( double  precision )

virtual

Definition at line 562 of file TMultiDimFet.cc.

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

                                                        {
  // 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);
}

GetChi2()

Double_t TMultiDimFet::GetChi2 ( ) const

inline

Definition at line 147 of file TMultiDimFet.h.

References fChi2.

{ return fChi2; }

GetCoefficients()

const TVectorD* TMultiDimFet::GetCoefficients ( ) const

inline

Definition at line 149 of file TMultiDimFet.h.

References fCoefficients.

{ return &fCoefficients; }

GetCorrelationMatrix()

const TMatrixD* TMultiDimFet::GetCorrelationMatrix ( ) const

inline

Definition at line 148 of file TMultiDimFet.h.

References fCorrelationMatrix.

{ return &fCorrelationMatrix; }

GetError()

Double_t TMultiDimFet::GetError ( ) const

inline

Definition at line 150 of file TMultiDimFet.h.

References fError.

{ return fError; }

GetFunctionCodes()

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

inline

Definition at line 151 of file TMultiDimFet.h.

References fFunctionCodes.

{ return fFunctionCodes; }

GetFunctions()

const TMatrixD* TMultiDimFet::GetFunctions ( ) const

inline

Definition at line 152 of file TMultiDimFet.h.

References fFunctions.

{ return &fFunctions; }

GetHistograms()

virtual TList* TMultiDimFet::GetHistograms ( ) const

inlinevirtual

Definition at line 153 of file TMultiDimFet.h.

References fHistograms.

{ return fHistograms; }

GetMaxAngle()

Double_t TMultiDimFet::GetMaxAngle ( ) const

inline

Definition at line 154 of file TMultiDimFet.h.

References fMaxAngle.

{ return fMaxAngle; }

GetMaxFunctions()

Int_t TMultiDimFet::GetMaxFunctions ( ) const

inline

Definition at line 155 of file TMultiDimFet.h.

References fMaxFunctions.

{ return fMaxFunctions; }

GetMaxPowers()

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

inline

Definition at line 156 of file TMultiDimFet.h.

References fMaxPowers.

{ return fMaxPowers; }

GetMaxQuantity()

Double_t TMultiDimFet::GetMaxQuantity ( ) const

inline

Definition at line 157 of file TMultiDimFet.h.

References fMaxQuantity.

{ return fMaxQuantity; }

GetMaxStudy()

Int_t TMultiDimFet::GetMaxStudy ( ) const

inline

Definition at line 158 of file TMultiDimFet.h.

References fMaxStudy.

{ return fMaxStudy; }

GetMaxTerms()

Int_t TMultiDimFet::GetMaxTerms ( ) const

inline

Definition at line 159 of file TMultiDimFet.h.

References fMaxTerms.

{ return fMaxTerms; }

GetMaxVariables()

const TVectorD* TMultiDimFet::GetMaxVariables ( ) const

inline

Definition at line 160 of file TMultiDimFet.h.

References fMaxVariables.

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

{ return &fMaxVariables; }

GetMeanQuantity()

Double_t TMultiDimFet::GetMeanQuantity ( ) const

inline

Definition at line 161 of file TMultiDimFet.h.

References fMeanQuantity.

{ return fMeanQuantity; }

GetMeanVariables()

const TVectorD* TMultiDimFet::GetMeanVariables ( ) const

inline

Definition at line 162 of file TMultiDimFet.h.

References fMeanVariables.

{ return &fMeanVariables; }

GetMinAngle()

Double_t TMultiDimFet::GetMinAngle ( ) const

inline

Definition at line 163 of file TMultiDimFet.h.

References fMinAngle.

{ return fMinAngle; }

GetMinQuantity()

Double_t TMultiDimFet::GetMinQuantity ( ) const

inline

Definition at line 164 of file TMultiDimFet.h.

References fMinQuantity.

{ return fMinQuantity; }

GetMinRelativeError()

Double_t TMultiDimFet::GetMinRelativeError ( ) const

inline

Definition at line 165 of file TMultiDimFet.h.

References fMinRelativeError.

{ return fMinRelativeError; }

GetMinVariables()

const TVectorD* TMultiDimFet::GetMinVariables ( ) const

inline

Definition at line 166 of file TMultiDimFet.h.

References fMinVariables.

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

{ return &fMinVariables; }

GetNCoefficients()

Int_t TMultiDimFet::GetNCoefficients ( ) const

inline

Definition at line 168 of file TMultiDimFet.h.

References fNCoefficients.

{ return fNCoefficients; }

GetNVariables()

Int_t TMultiDimFet::GetNVariables ( ) const

inline

Definition at line 167 of file TMultiDimFet.h.

References fNVariables.

{ return fNVariables; }

GetPolyType()

Int_t TMultiDimFet::GetPolyType ( ) const

inline

Definition at line 169 of file TMultiDimFet.h.

References fPolyType.

{ return fPolyType; }

GetPowerIndex()

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

inline

Definition at line 170 of file TMultiDimFet.h.

References fPowerIndex.

{ return fPowerIndex; }

GetPowerLimit()

Double_t TMultiDimFet::GetPowerLimit ( ) const

inline

Definition at line 171 of file TMultiDimFet.h.

References fPowerLimit.

{ return fPowerLimit; }

GetPowers()

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

inline

Definition at line 172 of file TMultiDimFet.h.

References fPowers.

{ return fPowers; }

GetPrecision()

Double_t TMultiDimFet::GetPrecision ( ) const

inline

Definition at line 173 of file TMultiDimFet.h.

References fPrecision.

{ return fPrecision; }

GetQuantity()

const TVectorD* TMultiDimFet::GetQuantity ( ) const

inline

Definition at line 174 of file TMultiDimFet.h.

References fQuantity.

{ return &fQuantity; }

GetResidualMax()

Double_t TMultiDimFet::GetResidualMax ( ) const

inline

Definition at line 175 of file TMultiDimFet.h.

References fMaxResidual.

{ return fMaxResidual; }

GetResidualMaxRow()

Int_t TMultiDimFet::GetResidualMaxRow ( ) const

inline

Definition at line 177 of file TMultiDimFet.h.

References fMaxResidualRow.

{ return fMaxResidualRow; }

GetResidualMin()

Double_t TMultiDimFet::GetResidualMin ( ) const

inline

Definition at line 176 of file TMultiDimFet.h.

References fMinResidual.

{ return fMinResidual; }

GetResidualMinRow()

Int_t TMultiDimFet::GetResidualMinRow ( ) const

inline

Definition at line 178 of file TMultiDimFet.h.

References fMinResidualRow.

{ return fMinResidualRow; }

GetResidualSumSq()

Double_t TMultiDimFet::GetResidualSumSq ( ) const

inline

Definition at line 179 of file TMultiDimFet.h.

References fSumSqResidual.

{ return fSumSqResidual; }

GetRMS()

Double_t TMultiDimFet::GetRMS ( ) const

inline

Definition at line 180 of file TMultiDimFet.h.

References fRMS.

{ return fRMS; }

GetSampleSize()

Int_t TMultiDimFet::GetSampleSize ( ) const

inline

Definition at line 181 of file TMultiDimFet.h.

References fSampleSize.

{ return fSampleSize; }

GetSqError()

const TVectorD* TMultiDimFet::GetSqError ( ) const

inline

Definition at line 182 of file TMultiDimFet.h.

References fSqError.

{ return &fSqError; }

GetSumSqAvgQuantity()

Double_t TMultiDimFet::GetSumSqAvgQuantity ( ) const

inline

Definition at line 183 of file TMultiDimFet.h.

References fSumSqAvgQuantity.

{ return fSumSqAvgQuantity; }

GetSumSqQuantity()

Double_t TMultiDimFet::GetSumSqQuantity ( ) const

inline

Definition at line 184 of file TMultiDimFet.h.

References fSumSqQuantity.

{ return fSumSqQuantity; }

GetTestError()

Double_t TMultiDimFet::GetTestError ( ) const

inline

Definition at line 185 of file TMultiDimFet.h.

References fTestError.

{ return fTestError; }

GetTestPrecision()

Double_t TMultiDimFet::GetTestPrecision ( ) const

inline

Definition at line 186 of file TMultiDimFet.h.

References fTestPrecision.

{ return fTestPrecision; }

GetTestQuantity()

const TVectorD* TMultiDimFet::GetTestQuantity ( ) const

inline

Definition at line 187 of file TMultiDimFet.h.

References fTestQuantity.

{ return &fTestQuantity; }

GetTestSampleSize()

Int_t TMultiDimFet::GetTestSampleSize ( ) const

inline

Definition at line 188 of file TMultiDimFet.h.

References fTestSampleSize.

{ return fTestSampleSize; }

GetTestSqError()

const TVectorD* TMultiDimFet::GetTestSqError ( ) const

inline

Definition at line 189 of file TMultiDimFet.h.

References fTestSqError.

{ return &fTestSqError; }

GetTestVariables()

const TVectorD* TMultiDimFet::GetTestVariables ( ) const

inline

Definition at line 190 of file TMultiDimFet.h.

References fTestVariables.

{ return &fTestVariables; }

GetVariables()

const TVectorD* TMultiDimFet::GetVariables ( ) const

inline

Definition at line 191 of file TMultiDimFet.h.

References fVariables.

{ return &fVariables; }

IsFolder()

Bool_t TMultiDimFet::IsFolder ( ) const

inlineoverride

Definition at line 194 of file TMultiDimFet.h.

{ return kTRUE; }

MakeCandidates()

void TMultiDimFet::MakeCandidates ( )

protectedvirtual

Definition at line 658 of file TMultiDimFet.cc.

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().

                                  {
  // 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;

    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;
}

MakeChi2()

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

virtual

Definition at line 779 of file TMultiDimFet.cc.

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

                                                     {
  // 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;
}

MakeCode()

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

virtual

Definition at line 807 of file TMultiDimFet.cc.

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

                                                                  {
  // 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);
}

MakeCoefficientErrors()

void TMultiDimFet::MakeCoefficientErrors ( )

protectedvirtual

Definition at line 839 of file TMultiDimFet.cc.

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

                                         {
  // 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));
}

MakeCoefficients()

void TMultiDimFet::MakeCoefficients ( )

protectedvirtual

Definition at line 888 of file TMultiDimFet.cc.

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().

                                    {
  // 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
}

MakeCorrelation()

void TMultiDimFet::MakeCorrelation ( )

protectedvirtual

Definition at line 964 of file TMultiDimFet.cc.

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

                                   {
  // 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);
    }
  }
}

MakeGramSchmidt()

Double_t TMultiDimFet::MakeGramSchmidt ( Int_t  function )

protectedvirtual

Definition at line 1013 of file TMultiDimFet.cc.

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().

                                                     {
  // 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;
}

MakeHistograms()

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

virtual

Definition at line 1086 of file TMultiDimFet.cc.

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.

                                                  {
  // 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));
  }
}

MakeMethod()

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

virtual

Definition at line 1199 of file TMultiDimFet.cc.

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

                                                                       {
  // 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);
}

MakeNormalized()

void TMultiDimFet::MakeNormalized ( )

protectedvirtual

Definition at line 1248 of file TMultiDimFet.cc.

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().

                                  {
  // 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));
  }
}

MakeParameterization()

void TMultiDimFet::MakeParameterization ( )

protectedvirtual

Definition at line 1295 of file TMultiDimFet.cc.

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(), METSkim_cff::Max, PARAM_MAXSTUDY, PARAM_MAXTERMS, PARAM_RELERR, PARAM_SEVERAL, alignCSCRings::s, and TestFunction().

Referenced by FindParameterization().

                                        {
  // 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);
}

MakeRealCode()

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

protectedvirtual

Definition at line 1440 of file TMultiDimFet.cc.

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().

                                                                                       {
  // 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";
}

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

Multi Correlation coefficient

List of histograms

Bit pattern of hisograms used

Definition at line 83 of file TMultiDimFet.cc.

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.

                                                                  {
  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;
}

Print()

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

override

Definition at line 1683 of file TMultiDimFet.cc.

References 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.

                                               {
  // 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";
  }
}

PrintPolynomialsSpecial()

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

virtual

Definition at line 1916 of file TMultiDimFet.cc.

References 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.

                                                                 {
  //   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";
  }
}

ReducePolynomial()

void TMultiDimFet::ReducePolynomial

(

double

error

)

Definition at line 466 of file TMultiDimFet.cc.

References relativeConstraints::error, and ZeroDoubiousCoefficients().

Referenced by FindParameterization().

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

Select()

Bool_t TMultiDimFet::Select ( const Int_t *  iv )

protectedvirtual

Definition at line 1979 of file TMultiDimFet.cc.

Referenced by MakeCandidates().

                                         {
  // 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;
}

SetMaxAngle()

void TMultiDimFet::SetMaxAngle

(

Double_t

angle = 0

)

Definition at line 1993 of file TMultiDimFet.cc.

References fMaxAngle.

Referenced by LHCOpticsApproximator::SetDefaultAproximatorSettings().

                                           {
  // 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;
}

SetMaxFunctions()

void TMultiDimFet::SetMaxFunctions ( Int_t  n )

inline

Definition at line 203 of file TMultiDimFet.h.

References fMaxFunctions, and dqmiodumpmetadata::n.

Referenced by LHCOpticsApproximator::SetDefaultAproximatorSettings().

{ fMaxFunctions = n; }

SetMaxPowers()

void TMultiDimFet::SetMaxPowers

(

const Int_t *

powers

)

Definition at line 2051 of file TMultiDimFet.cc.

References fMaxPowers, fNVariables, and mps_fire::i.

Referenced by LHCOpticsApproximator::SetDefaultAproximatorSettings().

                                                   {
  // 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;
}

SetMaxStudy()

void TMultiDimFet::SetMaxStudy ( Int_t  n )

inline

Definition at line 205 of file TMultiDimFet.h.

References fMaxStudy, and dqmiodumpmetadata::n.

Referenced by LHCOpticsApproximator::SetDefaultAproximatorSettings().

{ fMaxStudy = n; }

SetMaxTerms()

void TMultiDimFet::SetMaxTerms ( Int_t  terms )

inline

Definition at line 206 of file TMultiDimFet.h.

References fMaxTerms.

Referenced by LHCOpticsApproximator::SetDefaultAproximatorSettings().

{ fMaxTerms = terms; }

SetMinAngle()

void TMultiDimFet::SetMinAngle

(

Double_t

angle = 1

)

Definition at line 2008 of file TMultiDimFet.cc.

References fMinAngle.

Referenced by LHCOpticsApproximator::SetDefaultAproximatorSettings().

                                           {
  // 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;
}

SetMinRelativeError()

void TMultiDimFet::SetMinRelativeError

(

Double_t

error

)

Definition at line 2063 of file TMultiDimFet.cc.

References relativeConstraints::error, and fMinRelativeError.

Referenced by LHCOpticsApproximator::SetDefaultAproximatorSettings().

                                                     {
  // 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;
}

SetPowerLimit()

void TMultiDimFet::SetPowerLimit

(

Double_t

limit = 1e-3

)

Definition at line 2042 of file TMultiDimFet.cc.

References fPowerLimit, and remoteMonitoring_LASER_era2018_cfg::limit.

Referenced by LHCOpticsApproximator::SetDefaultAproximatorSettings().

                                               {
  // 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;
}

SetPowers()

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

virtual

Definition at line 2022 of file TMultiDimFet.cc.

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

Referenced by LHCOpticsApproximator::SetTermsManually().

                                                             {
  // 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;
}

TestFunction()

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

protectedvirtual

Definition at line 2072 of file TMultiDimFet.cc.

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

Referenced by MakeParameterization().

                                                                            {
  // 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;
}

ZeroDoubiousCoefficients()

void TMultiDimFet::ZeroDoubiousCoefficients

(

double

error

)

Definition at line 474 of file TMultiDimFet.cc.

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

Referenced by ReducePolynomial().

                                                        {
  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";
}

Member Data Documentation

fChi2

Double_t TMultiDimFet::fChi2

protected

Root mean square of fit.

Definition at line 96 of file TMultiDimFet.h.

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

fCoefficients

TVectorD TMultiDimFet::fCoefficients

protected

Model matrix.

Definition at line 93 of file TMultiDimFet.h.

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

fCoefficientsRMS

TVectorD TMultiDimFet::fCoefficientsRMS

protected

Definition at line 94 of file TMultiDimFet.h.

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

fCorrelationCoeff

Double_t TMultiDimFet::fCorrelationCoeff

protected

Relative precision of test.

Definition at line 103 of file TMultiDimFet.h.

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

fCorrelationMatrix

TMatrixD TMultiDimFet::fCorrelationMatrix

protected

Multi Correlation coefficient.

Definition at line 104 of file TMultiDimFet.h.

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

fError

Double_t TMultiDimFet::fError

protected

Exit code of parameterisation.

Definition at line 99 of file TMultiDimFet.h.

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

fFunctionCodes

std::vector<Int_t> TMultiDimFet::fFunctionCodes

protected

Definition at line 72 of file TMultiDimFet.h.

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

fFunctions

TMatrixD TMultiDimFet::fFunctions

protected

Control parameter.

Definition at line 70 of file TMultiDimFet.h.

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

fHistogramMask

Byte_t TMultiDimFet::fHistogramMask

protected

List of histograms.

Definition at line 108 of file TMultiDimFet.h.

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

fHistograms

TList* TMultiDimFet::fHistograms

protected

Multi Correlation coefficient.

Definition at line 107 of file TMultiDimFet.h.

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

fIsUserFunction

Bool_t TMultiDimFet::fIsUserFunction

protected

Definition at line 114 of file TMultiDimFet.h.

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

fIsVerbose

Bool_t TMultiDimFet::fIsVerbose

protected

Definition at line 115 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 64 of file TMultiDimFet.h.

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

fMaxFunctions

Int_t TMultiDimFet::fMaxFunctions

protected

Functions evaluated over sample.

Definition at line 71 of file TMultiDimFet.h.

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

fMaxFunctionsTimesNVariables

Int_t TMultiDimFet::fMaxFunctionsTimesNVariables

protected

maximum powers from fit, ex-array

Definition at line 79 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 67 of file TMultiDimFet.h.

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

fMaxPowersFinal

std::vector<Int_t> TMultiDimFet::fMaxPowersFinal

protected

Norm of the evaluated functions.

Definition at line 78 of file TMultiDimFet.h.

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

fMaxQuantity

Double_t TMultiDimFet::fMaxQuantity

protected

Definition at line 44 of file TMultiDimFet.h.

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

fMaxResidual

Double_t TMultiDimFet::fMaxResidual

protected

Vector of the final residuals.

Definition at line 84 of file TMultiDimFet.h.

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

fMaxResidualRow

Int_t TMultiDimFet::fMaxResidualRow

protected

Min redsidual value.

Definition at line 86 of file TMultiDimFet.h.

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

fMaxStudy

Int_t TMultiDimFet::fMaxStudy

protected

acceptance code, ex-array

Definition at line 73 of file TMultiDimFet.h.

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

fMaxTerms

Int_t TMultiDimFet::fMaxTerms

protected

Max angle for acepting new function.

Definition at line 65 of file TMultiDimFet.h.

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

fMaxVariables

TVectorD TMultiDimFet::fMaxVariables

protected

mean value of independent variables

Definition at line 52 of file TMultiDimFet.h.

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

fMeanQuantity

Double_t TMultiDimFet::fMeanQuantity

protected

Training sample, error in quantity.

Definition at line 43 of file TMultiDimFet.h.

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

fMeanVariables

TVectorD TMultiDimFet::fMeanVariables

protected

Definition at line 51 of file TMultiDimFet.h.

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

fMinAngle

Double_t TMultiDimFet::fMinAngle

protected

Size of test sample.

Definition at line 63 of file TMultiDimFet.h.

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

fMinQuantity

Double_t TMultiDimFet::fMinQuantity

protected

Max value of dependent quantity.

Definition at line 45 of file TMultiDimFet.h.

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

fMinRelativeError

Double_t TMultiDimFet::fMinRelativeError

protected

Definition at line 66 of file TMultiDimFet.h.

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

fMinResidual

Double_t TMultiDimFet::fMinResidual

protected

Max redsidual value.

Definition at line 85 of file TMultiDimFet.h.

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

fMinResidualRow

Int_t TMultiDimFet::fMinResidualRow

protected

Row giving max residual.

Definition at line 87 of file TMultiDimFet.h.

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

fMinVariables

TVectorD TMultiDimFet::fMinVariables

protected

Definition at line 53 of file TMultiDimFet.h.

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

fNCoefficients

Int_t TMultiDimFet::fNCoefficients

protected

Sum of Square residuals.

Definition at line 90 of file TMultiDimFet.h.

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

fNVariables

Int_t TMultiDimFet::fNVariables

protected

Training sample, independent variables.

Definition at line 50 of file TMultiDimFet.h.

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

fOrthCoefficients

TVectorD TMultiDimFet::fOrthCoefficients

protected

Definition at line 91 of file TMultiDimFet.h.

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

fOrthCurvatureMatrix

TMatrixD TMultiDimFet::fOrthCurvatureMatrix

protected

The model coefficients.

Definition at line 92 of file TMultiDimFet.h.

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

fOrthFunctionNorms

TVectorD TMultiDimFet::fOrthFunctionNorms

protected

As above, but orthogonalised.

Definition at line 76 of file TMultiDimFet.h.

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

fOrthFunctions

TMatrixD TMultiDimFet::fOrthFunctions

protected

max functions to study

Definition at line 75 of file TMultiDimFet.h.

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

fParameterisationCode

Int_t TMultiDimFet::fParameterisationCode

protected

Chi square of fit.

Definition at line 97 of file TMultiDimFet.h.

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

fPolyType

EMDFPolyType TMultiDimFet::fPolyType

protected

Bit pattern of hisograms used.

Definition at line 112 of file TMultiDimFet.h.

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

fPowerIndex

std::vector<Int_t> TMultiDimFet::fPowerIndex

protected

Definition at line 81 of file TMultiDimFet.h.

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

fPowerLimit

Double_t TMultiDimFet::fPowerLimit

protected

maximum powers, ex-array

Definition at line 68 of file TMultiDimFet.h.

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

fPowers

std::vector<Int_t> TMultiDimFet::fPowers

protected

Definition at line 80 of file TMultiDimFet.h.

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

fPrecision

Double_t TMultiDimFet::fPrecision

protected

Error from test.

Definition at line 101 of file TMultiDimFet.h.

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

fQuantity

TVectorD TMultiDimFet::fQuantity

protected

Definition at line 41 of file TMultiDimFet.h.

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

fResiduals

TVectorD TMultiDimFet::fResiduals

protected

Definition at line 83 of file TMultiDimFet.h.

Referenced by Clear(), and MakeCoefficients().

fRMS

Double_t TMultiDimFet::fRMS

protected

Vector of RMS of coefficients.

Definition at line 95 of file TMultiDimFet.h.

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

fSampleSize

Int_t TMultiDimFet::fSampleSize

protected

Definition at line 55 of file TMultiDimFet.h.

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

fShowCorrelation

Bool_t TMultiDimFet::fShowCorrelation

protected

Definition at line 113 of file TMultiDimFet.h.

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

fSqError

TVectorD TMultiDimFet::fSqError

protected

Training sample, dependent quantity.

Definition at line 42 of file TMultiDimFet.h.

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

fSumSqAvgQuantity

Double_t TMultiDimFet::fSumSqAvgQuantity

protected

SumSquare of dependent quantity.

Definition at line 47 of file TMultiDimFet.h.

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

fSumSqQuantity

Double_t TMultiDimFet::fSumSqQuantity

protected

Min value of dependent quantity.

Definition at line 46 of file TMultiDimFet.h.

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

fSumSqResidual

Double_t TMultiDimFet::fSumSqResidual

protected

Row giving min residual.

Definition at line 88 of file TMultiDimFet.h.

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

fTestCorrelationCoeff

Double_t TMultiDimFet::fTestCorrelationCoeff

protected

Correlation matrix.

Definition at line 105 of file TMultiDimFet.h.

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

fTestError

Double_t TMultiDimFet::fTestError

protected

Error from parameterization.

Definition at line 100 of file TMultiDimFet.h.

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

fTestPrecision

Double_t TMultiDimFet::fTestPrecision

protected

Relative precision of param.

Definition at line 102 of file TMultiDimFet.h.

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

fTestQuantity

TVectorD TMultiDimFet::fTestQuantity

protected

Size of training sample.

Definition at line 57 of file TMultiDimFet.h.

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

fTestSampleSize

Int_t TMultiDimFet::fTestSampleSize

protected

Test sample, independent variables.

Definition at line 61 of file TMultiDimFet.h.

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

fTestSqError

TVectorD TMultiDimFet::fTestSqError

protected

Test sample, dependent quantity.

Definition at line 58 of file TMultiDimFet.h.

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

fTestVariables

TVectorD TMultiDimFet::fTestVariables

protected

Test sample, Error in quantity.

Definition at line 59 of file TMultiDimFet.h.

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

fVariables

TVectorD TMultiDimFet::fVariables

protected

Sum of squares away from mean.

Definition at line 49 of file TMultiDimFet.h.

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