Class responsible for handling Principal Component Analysis (PCA) of covariance matrix. More...

#include <Parameters/PCAHandler.h>

Collaboration diagram for PCAHandler:

Public Member Functions
	PCAHandler ()
	Constructor.

virtual	~PCAHandler ()
	Destructor.

void	Print ()
	KS: Print info about PCA parameters.

int	GetNumberPCAedParameters () const
	Retrieve number of parameters in PCA base.

void	SetupPointers (std::vector< double > fCurr_Val, std::vector< double > fProp_Val)
	KS: Setup pointers to current and proposed parameter value which we need to convert them to PCA base each step.

void	ConstructPCA (TMatrixDSym *CovMatrix, const int firstPCAd, const int lastPCAd, const double eigen_thresh, const int _fNumPar)
	CW: Calculate eigen values, prepare transition matrices and remove param based on defined threshold.

void	TransferToPCA ()
	Transfer param values from normal base to PCA base.

void	TransferToParam ()
	Transfer param values from PCA base to normal base.

void	ThrowParameters (const std::vector< std::unique_ptr< TRandom3 > > &random_number, double *throwMatrixCholDecomp, double randParams, double *corr_throw, const std::vector< double > &fPreFitValue, const std::vector< double > &fLowBound, const std::vector< double > &fUpBound, int _fNumPar)
	Throw the parameters according to the covariance matrix. This shouldn't be used in MCMC code ase it can break Detailed Balance;.

void	AcceptStep () _noexcept_
	Accepted this step.

void	CorrelateSteps (const std::vector< double > &IndivStepScale, const double GlobalStepScale, const double _restrict_ randParams, const double _restrict_ corr_throw) _noexcept_
	Use Cholesky throw matrix for better step proposal.

void	SetInitialParameters (std::vector< double > &IndStepScale)
	KS: Transfer the starting parameters to the PCA basis, you don't want to start with zero..

void	ThrowParProp (const double mag, const double *_restrict_ randParams)
	Throw the proposed parameter by mag sigma.

void	ThrowParCurr (const double mag, const double *_restrict_ randParams)
	Helper function to throw the current parameter by mag sigma.

void	SetBranches (TTree &tree, bool SaveProposal, const std::vector< std::string > &Names)
	set branches for output file

void	ToggleFixAllParameters ()
	fix parameters at prior values

void	ToggleFixParameter (const int i, const std::vector< std::string > &Names)
	fix parameters at prior values

void	SetParametersPCA (const std::vector< double > &pars)
	Set values for PCA parameters in PCA base.

bool	IsParameterFixedPCA (const int i) const
	Is parameter fixed in PCA base or not.

const TMatrixD	GetEigenVectors () const
	Get eigen vectors of covariance matrix, only works with PCA.

void	SetParPropPCA (const int i, const double value)
	Set proposed value for parameter in PCA base.

void	SetParCurrPCA (const int i, const double value)
	Set current value for parameter in PCA base.

double	GetParPropPCA (const int i) const
	Get current parameter value using PCA.

double	GetPreFitValuePCA (const int i) const
	Get current parameter value using PCA.

double	GetParCurrPCA (const int i) const
	Get current parameter value using PCA.

const TMatrixD	GetTransferMatrix () const
	Get transfer matrix allowing to go from PCA base to normal base.

const TVectorD	GetEigenValues () const
	Get eigen values for all parameters, if you want for decomposed only parameters use GetEigenValuesMaster.

const std::vector< double >	GetEigenValuesMaster () const
	Get eigen value of only decomposed parameters, if you want for all parameters use GetEigenValues.

bool	IsParameterDecomposed (const int i) const
	Check if parameter in PCA base is decomposed or not.

Private Member Functions
void	SanitisePCA (TMatrixDSym *CovMatrix)
	@biref KS: Make sure decomposed matrix isn't correlated with undecomposed

Private Attributes
std::vector< double >	_fPreFitValuePCA
	Prefit value for PCA params.

TVectorD	_fParPropPCA
	CW: Current parameter value in PCA base.

TVectorD	_fParCurrPCA
	CW: Proposed parameter value in PCA base.

std::vector< double >	_fErrorPCA
	Tells if parameter is fixed in PCA base or not.

std::vector< int >	isDecomposedPCA
	If param is decomposed this will return -1, if not this will return enumerator to param in normal base. This way we can map stuff like step scale etc between normal base and undecomposed param in eigen base.

int	NumParPCA
	Number of parameters in PCA base.

TMatrixD	TransferMat
	Matrix used to converting from PCA base to normal base.

TMatrixD	TransferMatT
	Matrix used to converting from normal base to PCA base.

TVectorD	eigen_values
	Eigen value only of particles which are being decomposed.

TMatrixD	eigen_vectors
	Eigen vectors only of params which are being decomposed.

std::vector< double >	eigen_values_master
	Eigen values which have dimension equal to _fNumParPCA, and can be used in CorrelateSteps.

int	nKeptPCApars
	Total number that remained after applying PCA Threshold.

int	FirstPCAdpar
	Index of the first param that is being decomposed.

int	LastPCAdpar
	Index of the last param that is being decomposed.

double	eigen_threshold
	CW: Threshold based on which we remove parameters in eigen base.

std::vector< double > *	_pCurrVal
	Pointer to current value of the parameter.

std::vector< double > *	_pPropVal
	Pointer to proposed value of the parameter.

Detailed Description

Class responsible for handling Principal Component Analysis (PCA) of covariance matrix.

See also: For more details, visit the Wiki.

Author: Clarence Wret

Definition at line 30 of file PCAHandler.h.

Constructor & Destructor Documentation

◆ PCAHandler()

PCAHandler::PCAHandler ( )

Constructor.

Definition at line 5 of file PCAHandler.cpp.

                       {
// ********************************************
  _pCurrVal = nullptr;
  _pPropVal = nullptr;
}

◆ ~PCAHandler()

PCAHandler::~PCAHandler ( )

virtual

Destructor.

Definition at line 12 of file PCAHandler.cpp.

                        {
// ********************************************
 
}

Member Function Documentation

◆ AcceptStep()

void PCAHandler::AcceptStep ( )

Accepted this step.

Definition at line 183 of file PCAHandler.cpp.

                                       {
// ********************************************
  // Update the book-keeping for the output
  #ifdef MULTITHREAD
  #pragma omp parallel for
  #endif
  for (int i = 0; i < NumParPCA; ++i) {
    _fParCurrPCA(i) = _fParPropPCA(i);
  }
  // Then update the parameter basis
  TransferToParam();
}

◆ ConstructPCA()

void PCAHandler::ConstructPCA	(	TMatrixDSym *	CovMatrix,
		const int	firstPCAd,
		const int	lastPCAd,
		const double	eigen_thresh,
		const int	_fNumPar
	)

CW: Calculate eigen values, prepare transition matrices and remove param based on defined threshold.

Parameters

CovMatrix	Symmetric covariance matrix used for eigen decomposition.
firstPCAd	Index of the first PCA component to include.
lastPCAd	Index of the last PCA component to include.
eigen_thresh	Threshold for eigenvalues below which parameters are discarded.
_fNumPar	Total number of parameters in the original (non-PCA) basis.

Definition at line 26 of file PCAHandler.cpp.

                                                                             {
// ********************************************
  FirstPCAdpar = firstPCAd;
  LastPCAdpar = lastPCAd;
  eigen_threshold = eigen_thresh;
 
  // Check that covariance matrix exists
  if (CovMatrix == NULL) {
    MACH3LOG_ERROR("Covariance matrix for has not yet been set");
    MACH3LOG_ERROR("Can not construct PCA until it is set");
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  if(FirstPCAdpar > CovMatrix->GetNrows()-1 || LastPCAdpar>CovMatrix->GetNrows()-1) {
    MACH3LOG_ERROR("FirstPCAdpar and LastPCAdpar are higher than the number of parameters");
    MACH3LOG_ERROR("first: {} last: {}, params: {}", FirstPCAdpar, LastPCAdpar, CovMatrix->GetNrows()-1);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
  if(FirstPCAdpar < 0 || LastPCAdpar < 0){
    MACH3LOG_ERROR("FirstPCAdpar and LastPCAdpar are less than 0 but not default -999");
    MACH3LOG_ERROR("first: {} last: {}", FirstPCAdpar, LastPCAdpar);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
  MACH3LOG_INFO("PCAing parameters {} through {} inclusive", FirstPCAdpar, LastPCAdpar);
  int numunpcadpars = CovMatrix->GetNrows()-(LastPCAdpar-FirstPCAdpar+1);
 
  // KS: Make sure we are not doing anything silly with PCA
  SanitisePCA(CovMatrix);
 
  TMatrixDSym submat(CovMatrix->GetSub(FirstPCAdpar,LastPCAdpar,FirstPCAdpar,LastPCAdpar));
 
  //CW: Calculate how many eigen values this threshold corresponds to
  TMatrixDSymEigen eigen(submat);
  eigen_values.ResizeTo(eigen.GetEigenValues());
  eigen_vectors.ResizeTo(eigen.GetEigenVectors());
  eigen_values = eigen.GetEigenValues();
  eigen_vectors = eigen.GetEigenVectors();
  double sum = 0;
  // Loop over eigen values and sum them up
  for (int i = 0; i < eigen_values.GetNrows(); ++i) {
    sum += eigen_values(i);
  }
  nKeptPCApars = eigen_values.GetNrows();
  //CW: Now go through again and see how many eigen values correspond to threshold
  for (int i = 0; i < eigen_values.GetNrows(); ++i) {
    // Get the relative size of the eigen value
    double sig = eigen_values(i)/sum;
    // Check against the threshold
    if (sig < eigen_threshold) {
      nKeptPCApars = i;
      break;
    }
  }
  NumParPCA = numunpcadpars+nKeptPCApars;
  MACH3LOG_INFO("Threshold of {} on eigen values relative sum of eigen value ({}) generates {} eigen vectors, plus we have {} unpcad pars, for a total of {}", eigen_threshold, sum, nKeptPCApars, numunpcadpars, NumParPCA);
 
  //DB Create array of correct size so eigen_values can be used in CorrelateSteps
  eigen_values_master = std::vector<double>(NumParPCA, 1.0);
  for (int i = FirstPCAdpar; i < FirstPCAdpar+nKeptPCApars; ++i) {eigen_values_master[i] = eigen_values(i-FirstPCAdpar);}
 
  // Now construct the transfer matrices
  //These matrices will be as big as number of unPCAd pars plus number of eigenvalues kept
  TransferMat.ResizeTo(CovMatrix->GetNrows(), NumParPCA);
  TransferMatT.ResizeTo(CovMatrix->GetNrows(), NumParPCA);
 
  // Get a subset of the eigen vector matrix
  TMatrixD temp(eigen_vectors.GetSub(0, eigen_vectors.GetNrows()-1, 0, nKeptPCApars-1));
 
  //Make transfer matrix which is two blocks of identity with a block of the PCA transfer matrix in between
  TMatrixD temp2;
  temp2.ResizeTo(CovMatrix->GetNrows(), NumParPCA);
 
  //First set the whole thing to 0
  for(int iRow = 0; iRow < CovMatrix->GetNrows(); iRow++){
    for(int iCol = 0; iCol < NumParPCA; iCol++){
      temp2[iRow][iCol] = 0;
    }
  }
  //Set the first identity block
  if(FirstPCAdpar != 0){
    for(int iRow = 0; iRow < FirstPCAdpar; iRow++){
      temp2[iRow][iRow] = 1;
    }
  }
 
  //Set the transfer matrix block for the PCAd pars
  temp2.SetSub(FirstPCAdpar,FirstPCAdpar,temp);
 
  //Set the second identity block
  if(LastPCAdpar != CovMatrix->GetNrows()-1){
    for(int iRow = 0;iRow < (CovMatrix->GetNrows()-1)-LastPCAdpar; iRow++){
      temp2[LastPCAdpar+1+iRow][FirstPCAdpar+nKeptPCApars+iRow] = 1;
    }
  }
 
  TransferMat = temp2;
  // Copy the contents
  TransferMatT = TransferMat;
  // And then transpose
  TransferMatT.T();
 
  #ifdef DEBUG_PCA
  //KS: Let's dump all useful matrices to properly validate PCA
  DebugPCA(sum, temp, submat, CovMatrix->GetNrows());
  #endif
 
  // Make the PCA parameter arrays
  _fParCurrPCA.ResizeTo(NumParPCA);
  _fParPropPCA.ResizeTo(NumParPCA);
  _fPreFitValuePCA.resize(NumParPCA);
 
  //KS: make easy map so we could easily find un-decomposed parameters
  isDecomposedPCA.resize(NumParPCA);
  _fErrorPCA.resize(NumParPCA);
  for (int i = 0; i < NumParPCA; ++i)
  {
    _fErrorPCA[i] = 1;
    isDecomposedPCA[i] = -1;
  }
  for (int i = 0; i < FirstPCAdpar; ++i) isDecomposedPCA[i] = i;
 
  for (int i = FirstPCAdpar+nKeptPCApars+1; i < NumParPCA; ++i) isDecomposedPCA[i] = i+(_fNumPar-NumParPCA);
}

◆ CorrelateSteps()

void PCAHandler::CorrelateSteps	(	const std::vector< double > &	IndivStepScale,
		const double	GlobalStepScale,
		const double *_restrict_	randParams,
		const double *_restrict_	corr_throw
	)

Use Cholesky throw matrix for better step proposal.

Definition at line 198 of file PCAHandler.cpp.

                                                                                {
// ************************************************
  // Throw around the current step
  #ifdef MULTITHREAD
  #pragma omp parallel for
  #endif
  for (int i = 0; i < NumParPCA; ++i)
  {
    if (_fErrorPCA[i] > 0.)
    {
      double IndStepScale = 1.;
      //KS: If undecomposed parameter apply individual step scale and Cholesky for better acceptance rate
      if(isDecomposedPCA[i] >= 0)
      {
        IndStepScale *= IndivStepScale[isDecomposedPCA[i]];
        IndStepScale *= corr_throw[isDecomposedPCA[i]];
      }
      //If decomposed apply only random number
      else
      {
        IndStepScale *= randParams[i];
        //KS: All PCA-ed parameters have the same step scale
        IndStepScale *= IndivStepScale[FirstPCAdpar];
      }
      _fParPropPCA(i) = _fParCurrPCA(i)+GlobalStepScale*IndStepScale*eigen_values_master[i];
    }
  }
  // Then update the parameter basis
  TransferToParam();
}

◆ GetNumberPCAedParameters()

int PCAHandler::GetNumberPCAedParameters ( ) const

inline

Retrieve number of parameters in PCA base.

Definition at line 41 of file PCAHandler.h.

41{ return NumParPCA; }

◆ Print()

void PCAHandler::Print ( )

KS: Print info about PCA parameters.

Definition at line 303 of file PCAHandler.cpp.

                       {
// ********************************************
  MACH3LOG_INFO("PCA:");
  for (int i = 0; i < NumParPCA; ++i) {
    MACH3LOG_INFO("PCA {:<2} Current: {:<10.2f} Proposed: {:<10.2f}", i, _fParCurrPCA(i), _fParPropPCA(i));
  }
}

◆ SanitisePCA()

void PCAHandler::SanitisePCA ( TMatrixDSym * CovMatrix )

private

@biref KS: Make sure decomposed matrix isn't correlated with undecomposed

Definition at line 154 of file PCAHandler.cpp.

                                                   {
// ********************************************
  constexpr double correlation_threshold = 1e-6;
 
  bool found_significant_correlation = false;
 
  int N = CovMatrix->GetNrows();
  for (int i = FirstPCAdpar; i <= LastPCAdpar; ++i) {
    for (int j = 0; j < N; ++j) {
      // Skip if j is inside the decomposed range (we only want cross-correlations)
      if (j >= FirstPCAdpar && j <= LastPCAdpar) continue;
 
      double corr_val = (*CovMatrix)(i, j);
      if (std::fabs(corr_val) > correlation_threshold) {
        found_significant_correlation = true;
        MACH3LOG_ERROR("Significant correlation detected between decomposed parameter '{}' "
        "and undecomposed parameter '{}': {:.6e}", i, j, corr_val);
      }
    }
  }
 
  if (found_significant_correlation) {
    MACH3LOG_ERROR("There are correlations between undecomposed and decomposed part of matrices, this will not work");
    throw MaCh3Exception(__FILE__ , __LINE__);
  }
}

◆ SetInitialParameters()

void PCAHandler::SetInitialParameters ( std::vector< double > & IndStepScale )

KS: Transfer the starting parameters to the PCA basis, you don't want to start with zero..

Parameters

IndStepScale Per parameter step scale, we set so each PCA param uses same step scale [eigen value takes care of size]

Definition at line 249 of file PCAHandler.cpp.

                                                                     {
// ********************************************
  TransferToPCA();
  for (int i = 0; i < NumParPCA; ++i) {
    _fPreFitValuePCA[i] = _fParCurrPCA(i);
  }
  //DB Set Individual Step scale for PCA parameters to the LastPCAdpar fIndivStepScale because the step scale for those parameters is set by 'eigen_values[i]' but needs an overall step scale
  //   However, individual step scale for non-PCA parameters needs to be set correctly
  for (int i = FirstPCAdpar; i <= LastPCAdpar; i++) {
    IndStepScale[i] = IndStepScale[LastPCAdpar-1];
  }
}

◆ SetupPointers()

void PCAHandler::SetupPointers	(	std::vector< double > *	fCurr_Val,
		std::vector< double > *	fProp_Val
	)

KS: Setup pointers to current and proposed parameter value which we need to convert them to PCA base each step.

Parameters

fCurr_Val	pointer to current position of parameter
fProp_Val	pointer to proposed position of parameter

Definition at line 18 of file PCAHandler.cpp.

                                                             {
// ********************************************
  _pCurrVal = fCurr_Val;
  _pPropVal = fProp_Val;
}

◆ ThrowParameters()

void PCAHandler::ThrowParameters	(	const std::vector< std::unique_ptr< TRandom3 > > &	random_number,
		double **	throwMatrixCholDecomp,
		double *	randParams,
		double *	corr_throw,
		const std::vector< double > &	fPreFitValue,
		const std::vector< double > &	fLowBound,
		const std::vector< double > &	fUpBound,
		int	_fNumPar
	)

Throw the parameters according to the covariance matrix. This shouldn't be used in MCMC code ase it can break Detailed Balance;.

Todo:: KS: We don't check if param is out of bounds. This is more problematic for PCA params.

Definition at line 352 of file PCAHandler.cpp.

                                                     {
// ********************************************
  //KS: Do not multithread!
  for (int i = 0; i < NumParPCA; ++i) {
    // Check if parameter is fixed first: if so don't randomly throw
    if (IsParameterFixedPCA(i)) continue;
 
    if(!IsParameterDecomposed(i))
    {
      (*_pPropVal)[i] = fPreFitValue[i] + corr_throw[i];
      int throws = 0;
      // Try again if we the initial parameter proposal falls outside of the range of the parameter
      while ((*_pPropVal)[i] > fUpBound[i] || (*_pPropVal)[i] < fLowBound[i]) {
        randParams[i] = random_number[M3::GetThreadIndex()]->Gaus(0, 1);
        const double corr_throw_single = M3::MatrixVectorMultiSingle(throwMatrixCholDecomp, randParams, _fNumPar, i);
        (*_pPropVal)[i] = fPreFitValue[i] + corr_throw_single;
        if (throws > 10000)
        {
          //KS: Since we are multithreading there is danger that those messages
          //will be all over the place, small price to pay for faster code
          MACH3LOG_WARN("Tried {} times to throw parameter {} but failed", throws, i);
          MACH3LOG_WARN("Setting _fPropVal:  {} to {}", (*_pPropVal)[i], fPreFitValue[i]);
          MACH3LOG_WARN("I live at {}:{}", __FILE__, __LINE__);
         (*_pPropVal)[i] = fPreFitValue[i];
        }
        throws++;
      }
      (*_pCurrVal)[i] = (*_pPropVal)[i];
 
    } else {
      // KS: We have to multiply by number of parameters in PCA base
      SetParPropPCA(i, GetPreFitValuePCA(i) + randParams[i] * eigen_values_master[i] * (LastPCAdpar - FirstPCAdpar));
      SetParCurrPCA(i, GetParPropPCA(i));
    }
  } // end of parameter loop
 
  for (int i = 0; i < _fNumPar; ++i) {
    (*_pPropVal)[i] = std::max(fLowBound[i], std::min((*_pPropVal)[i], fUpBound[i]));
    (*_pCurrVal)[i] = (*_pPropVal)[i];
  }
}

◆ ThrowParCurr()

void PCAHandler::ThrowParCurr	(	const double	mag,
		const double *_restrict_	randParams
	)

Helper function to throw the current parameter by mag sigma.

Definition at line 292 of file PCAHandler.cpp.

                                                                                   {
// ********************************************
  for (int i = 0; i < NumParPCA; i++) {
    if (_fErrorPCA[i] > 0.) {
    _fParPropPCA(i) = mag*randParams[i];
    }
  }
  TransferToParam();
}

◆ ThrowParProp()

void PCAHandler::ThrowParProp	(	const double	mag,
		const double *_restrict_	randParams
	)

Throw the proposed parameter by mag sigma.

Definition at line 280 of file PCAHandler.cpp.

                                                                                   {
// ********************************************
  for (int i = 0; i < NumParPCA; i++) {
    if (_fErrorPCA[i] > 0.) {
    _fParPropPCA(i) = _fParCurrPCA(i)+mag*randParams[i];
    }
  }
  TransferToParam();
}

◆ TransferToParam()

void PCAHandler::TransferToParam ( )

Transfer param values from PCA base to normal base.

Definition at line 264 of file PCAHandler.cpp.

                                 {
// ********************************************
  // Make the temporary vectors
  TVectorD fParProp_vec = TransferMat*_fParPropPCA;
  TVectorD fParCurr_vec = TransferMat*_fParCurrPCA;
  #ifdef MULTITHREAD
  #pragma omp parallel for
  #endif
  for(int i = 0; i < static_cast<int>(_pCurrVal->size()); ++i) {
    (*_pPropVal)[i] = fParProp_vec(i);
    (*_pCurrVal)[i] = fParCurr_vec(i);
  }
}

◆ TransferToPCA()

void PCAHandler::TransferToPCA ( )

Transfer param values from normal base to PCA base.

Definition at line 234 of file PCAHandler.cpp.

                               {
// ********************************************
  // Make the temporary vectors
  TVectorD fParCurr_vec(static_cast<Int_t>(_pCurrVal->size()));
  TVectorD fParProp_vec(static_cast<Int_t>(_pCurrVal->size()));
  for(int i = 0; i < static_cast<int>(_pCurrVal->size()); ++i) {
    fParCurr_vec(i) = (*_pCurrVal)[i];
    fParProp_vec(i) = (*_pPropVal)[i];
  }
 
  _fParCurrPCA = TransferMatT*fParCurr_vec;
  _fParPropPCA = TransferMatT*fParProp_vec;
}

Member Data Documentation

◆ _fErrorPCA

std::vector<double> PCAHandler::_fErrorPCA

private

Tells if parameter is fixed in PCA base or not.

Definition at line 209 of file PCAHandler.h.

◆ _fParCurrPCA

TVectorD PCAHandler::_fParCurrPCA

private

CW: Proposed parameter value in PCA base.

Definition at line 207 of file PCAHandler.h.

◆ _fParPropPCA

TVectorD PCAHandler::_fParPropPCA

private

CW: Current parameter value in PCA base.

Definition at line 205 of file PCAHandler.h.

◆ _fPreFitValuePCA

std::vector<double> PCAHandler::_fPreFitValuePCA

private

Prefit value for PCA params.

Definition at line 203 of file PCAHandler.h.

◆ _pCurrVal

std::vector<double>* PCAHandler::_pCurrVal

private

Pointer to current value of the parameter.

Definition at line 236 of file PCAHandler.h.

◆ _pPropVal

std::vector<double>* PCAHandler::_pPropVal

private

Pointer to proposed value of the parameter.

Definition at line 238 of file PCAHandler.h.

◆ eigen_threshold

double PCAHandler::eigen_threshold

private

CW: Threshold based on which we remove parameters in eigen base.

Definition at line 233 of file PCAHandler.h.

◆ eigen_values

TVectorD PCAHandler::eigen_values

private

Eigen value only of particles which are being decomposed.

Definition at line 220 of file PCAHandler.h.

◆ eigen_values_master

std::vector<double> PCAHandler::eigen_values_master

private

Eigen values which have dimension equal to _fNumParPCA, and can be used in CorrelateSteps.

Definition at line 224 of file PCAHandler.h.

◆ eigen_vectors

TMatrixD PCAHandler::eigen_vectors

private

Eigen vectors only of params which are being decomposed.

Definition at line 222 of file PCAHandler.h.

◆ FirstPCAdpar

int PCAHandler::FirstPCAdpar

private

Index of the first param that is being decomposed.

Definition at line 229 of file PCAHandler.h.

◆ isDecomposedPCA

std::vector<int> PCAHandler::isDecomposedPCA

private

If param is decomposed this will return -1, if not this will return enumerator to param in normal base. This way we can map stuff like step scale etc between normal base and undecomposed param in eigen base.

Definition at line 211 of file PCAHandler.h.

◆ LastPCAdpar

int PCAHandler::LastPCAdpar

private

Index of the last param that is being decomposed.

Definition at line 231 of file PCAHandler.h.

◆ nKeptPCApars

int PCAHandler::nKeptPCApars

private

Total number that remained after applying PCA Threshold.

Definition at line 227 of file PCAHandler.h.

◆ NumParPCA

int PCAHandler::NumParPCA

private

Number of parameters in PCA base.

Definition at line 213 of file PCAHandler.h.

◆ TransferMat

TMatrixD PCAHandler::TransferMat

private

Matrix used to converting from PCA base to normal base.

Definition at line 216 of file PCAHandler.h.

◆ TransferMatT

TMatrixD PCAHandler::TransferMatT

private

Matrix used to converting from normal base to PCA base.

Definition at line 218 of file PCAHandler.h.

The documentation for this class was generated from the following files:

Parameters/PCAHandler.h
Parameters/PCAHandler.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PCAHandler()

◆ ~PCAHandler()

Member Function Documentation

◆ AcceptStep()

◆ ConstructPCA()

◆ CorrelateSteps()

◆ GetNumberPCAedParameters()

◆ Print()

◆ SanitisePCA()

◆ SetInitialParameters()

◆ SetupPointers()

◆ ThrowParameters()

◆ ThrowParCurr()

◆ ThrowParProp()

◆ TransferToParam()

◆ TransferToPCA()

Member Data Documentation

◆ _fErrorPCA

◆ _fParCurrPCA

◆ _fParPropPCA

◆ _fPreFitValuePCA

◆ _pCurrVal

◆ _pPropVal

◆ eigen_threshold

◆ eigen_values

◆ eigen_values_master

◆ eigen_vectors

◆ FirstPCAdpar

◆ isDecomposedPCA

◆ LastPCAdpar

◆ nKeptPCApars

◆ NumParPCA

◆ TransferMat

◆ TransferMatT