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

virtual	~PCAHandler ()
	Destructor. More...

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

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

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

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

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

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

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;. More...

void	AcceptStep () _noexcept_
	Accepted this step. More...

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

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

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

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

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

void	ToggleFixAllParameters ()
	fix parameters at prior values More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

TVectorD	_fParPropPCA
	CW: Current parameter value in PCA base. More...

TVectorD	_fParCurrPCA
	CW: Proposed parameter value in PCA base. More...

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

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

int	NumParPCA
	Number of parameters in PCA base. More...

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

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

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

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

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

int	nKeptPCApars
	Total number that remained after applying PCA Threshold. More...

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

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

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

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

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

Detailed Description

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

Author: Clarence Wret

Introduction

This class applies Principal Component Analysis (PCA) to covariance matrices using eigen-decomposition. The main benefit is that PCA rotates the parameter space into a basis where parameters are uncorrelated. In practice, this helps MCMC fits move more efficiently, since correlated directions in the original space often slow down convergence.

Dimensionality Reduction

PCA makes it possible to drop directions in parameter space with very small eigenvalues. These correspond to combinations of parameters that are poorly constrained or dominated by statistical noise. By applying a threshold (e.g. discarding eigenvalues smaller than 1e-4 of the largest one), the effective number of parameters can be reduced.

This is particularly useful in large MCMC fits, where many parameters may contribute little information. Removing them reduces dimensionality while keeping the dominant structure of the parameter space intact, often leading to faster and more stable fits.

Partial Decomposition

PCA does not need to be applied to the full covariance matrix. This class supports eigen-decomposition of only a submatrix. This is useful when only a subset of parameters is strongly correlated and benefits from PCA, while the rest remain in the original parameter basis.

See also: For more details, visit the Wiki.

Definition at line 60 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 71 of file PCAHandler.h.

71 { 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

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 239 of file PCAHandler.h.

◆ _fParCurrPCA

TVectorD PCAHandler::_fParCurrPCA

private

CW: Proposed parameter value in PCA base.

Definition at line 237 of file PCAHandler.h.

◆ _fParPropPCA

TVectorD PCAHandler::_fParPropPCA

private

CW: Current parameter value in PCA base.

Definition at line 235 of file PCAHandler.h.

◆ _fPreFitValuePCA

std::vector<double> PCAHandler::_fPreFitValuePCA

private

Prefit value for PCA params.

Definition at line 233 of file PCAHandler.h.

◆ _pCurrVal

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

private

Pointer to current value of the parameter.

Definition at line 266 of file PCAHandler.h.

◆ _pPropVal

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

private

Pointer to proposed value of the parameter.

Definition at line 268 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 263 of file PCAHandler.h.

◆ eigen_values

TVectorD PCAHandler::eigen_values

private

Eigen value only of particles which are being decomposed.

Definition at line 250 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 254 of file PCAHandler.h.

◆ eigen_vectors

TMatrixD PCAHandler::eigen_vectors

private

Eigen vectors only of params which are being decomposed.

Definition at line 252 of file PCAHandler.h.

◆ FirstPCAdpar

int PCAHandler::FirstPCAdpar

private

Index of the first param that is being decomposed.

Definition at line 259 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 241 of file PCAHandler.h.

◆ LastPCAdpar

int PCAHandler::LastPCAdpar

private

Index of the last param that is being decomposed.

Definition at line 261 of file PCAHandler.h.

◆ nKeptPCApars

int PCAHandler::nKeptPCApars

private

Total number that remained after applying PCA Threshold.

Definition at line 257 of file PCAHandler.h.

◆ NumParPCA

int PCAHandler::NumParPCA

private

Number of parameters in PCA base.

Definition at line 243 of file PCAHandler.h.

◆ TransferMat

TMatrixD PCAHandler::TransferMat

private

Matrix used to converting from PCA base to normal base.

Definition at line 246 of file PCAHandler.h.

◆ TransferMatT

TMatrixD PCAHandler::TransferMatT

private

Matrix used to converting from normal base to PCA base.

Definition at line 248 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

Introduction

Dimensionality Reduction

Partial Decomposition

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