Parameter Handler Setters

Functions
void	ParameterHandlerBase::SetCovMatrix (TMatrixDSym *cov)
	Set covariance matrix.
void	ParameterHandlerBase::SetName (const std::string &name)
	Set matrix name.
void	ParameterHandlerBase::SetParName (const int i, const std::string &name)
	change parameter name
void	ParameterHandlerBase::SetSingleParameter (const int parNo, const double parVal)
	Set value of single param to a given value.
void	ParameterHandlerBase::SetPar (const int i, const double val)
	Set all the covariance matrix parameters to a user-defined value.
void	ParameterHandlerBase::SetParCurrProp (const int i, const double val)
	Set current parameter value.
void	ParameterHandlerBase::SetParProp (const int i, const double val)
	Set proposed parameter value.
void	ParameterHandlerBase::SetParameters (const std::vector< double > &pars={})
	Set parameter values using vector, it has to have same size as covariance class.
void	ParameterHandlerBase::SetFlatPrior (const int i, const bool eL)
	Set if parameter should have flat prior or not.
void	ParameterHandlerBase::SetRandomThrow (const int i, const double rand)
	Set random value useful for debugging/CI.
void	ParameterHandlerBase::SetBranches (TTree &tree, const bool SaveProposal=false)
	set branches for output file
void	ParameterHandlerBase::SetStepScale (const double scale)
	Set global step scale for covariance object.
void	ParameterHandlerBase::SetIndivStepScale (const int ParameterIndex, const double StepScale)
	DB Function to set fIndivStepScale from a vector (Can be used from execs and inside covariance constructors)
void	ParameterHandlerBase::SetIndivStepScale (const std::vector< double > &stepscale)
	DB Function to set fIndivStepScale from a vector (Can be used from execs and inside covariance constructors)
void	ParameterHandlerBase::SetPrintLength (const unsigned int PriLen)
	KS: In case someone really want to change this.
void	ParameterHandlerBase::SetThrowMatrix (TMatrixDSym *cov)
	Use new throw matrix, used in adaptive MCMC.
void	ParameterHandlerBase::SetNumberOfSteps (const int nsteps)
	Set number of MCMC step, when running adaptive MCMC it is updated with given frequency. We need number of steps to determine frequency.
void	ParameterHandlerBase::SetTune (const std::string &TuneName)
	KS: Set proposed parameter values vector to be base on tune values, for example set proposed values to be of generated or maybe PostND.
void	ParameterHandlerGeneric::SetGroupOnlyParameters (const std::string &Group, const std::vector< double > &Pars={})
	KS Function to set to prior parameters of a given group or values from vector.
void	ParameterHandlerGeneric::SetGroupOnlyParameters (const std::vector< std::string > &Groups)
	KS Function to set to prior parameters of a given groups or values from vector.
void	PCAHandler::SetBranches (TTree &tree, bool SaveProposal, const std::vector< std::string > &Names)
	set branches for output file
void	PCAHandler::ToggleFixAllParameters ()
	fix parameters at prior values
void	PCAHandler::ToggleFixParameter (const int i, const std::vector< std::string > &Names)
	fix parameters at prior values
void	PCAHandler::SetParametersPCA (const std::vector< double > &pars)
	Set values for PCA parameters in PCA base.
void	PCAHandler::SetParPropPCA (const int i, const double value)
	Set proposed value for parameter in PCA base.
void	PCAHandler::SetParCurrPCA (const int i, const double value)
	Set current value for parameter in PCA base.

Detailed Description

Group of functions to set various parameters, names, and values.

Function Documentation

SetBranches() [1/2]

void PCAHandler::SetBranches	(	TTree &	tree,
		bool	SaveProposal,
		const std::vector< std::string > &	Names
	)

set branches for output file

Definition at line 312 of file PCAHandler.cpp.

                                                                                              {
// ********************************************
  for (int i = 0; i < NumParPCA; ++i) {
    tree.Branch(Form("%s_PCA", Names[i].c_str()), &_fParCurrPCA.GetMatrixArray()[i], Form("%s_PCA/D", Names[i].c_str()));
  }
 
  if(SaveProposal)
  {
    for (int i = 0; i < NumParPCA; ++i) {
      tree.Branch(Form("%s_PCA_Prop", Names[i].c_str()), &_fParPropPCA.GetMatrixArray()[i], Form("%s_PCA_Prop/D", Names[i].c_str()));
    }
  }
}

SetBranches() [2/2]

void ParameterHandlerBase::SetBranches	(	TTree &	tree,
		const bool	SaveProposal = false
	)

set branches for output file

Parameters

tree	Tree to which we will save branches
SaveProposal	Normally we only save parameter after is accepted, for debugging purpose it is helpful to see also proposed values. That's what this variable controls

Definition at line 843 of file ParameterHandlerBase.cpp.

                                                                     {
// ********************************************
  // loop over parameters and set a branch
  for (int i = 0; i < _fNumPar; ++i) {
    tree.Branch(_fNames[i].c_str(), &_fCurrVal[i], Form("%s/D", _fNames[i].c_str()));
  }
  // When running PCA, also save PCA parameters
  if (pca) {
    PCAObj->SetBranches(tree, SaveProposal, _fNames);
  }
  if(SaveProposal)
  {
    // loop over parameters and set a branch
    for (int i = 0; i < _fNumPar; ++i) {
      tree.Branch(Form("%s_Prop", _fNames[i].c_str()), &_fPropVal[i], Form("%s_Prop/D", _fNames[i].c_str()));
    }
  }
}

SetCovMatrix()

void ParameterHandlerBase::SetCovMatrix

(

TMatrixDSym *

cov

)

Set covariance matrix.

Parameters

cov	Covariance matrix which we set and will be used later for evaluation of penalty term

Definition at line 368 of file ParameterHandlerBase.cpp.

                                                        {
// ********************************************
  if (cov == nullptr) {
    MACH3LOG_ERROR("Could not find covariance matrix you provided to {}", __func__ );
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
  covMatrix = cov;
 
  invCovMatrix = static_cast<TMatrixDSym *>(cov->Clone());
  invCovMatrix->Invert();
  //KS: ROOT has bad memory management, using standard double means we can decrease most operation by factor 2 simply due to cache hits
  for (int i = 0; i < _fNumPar; i++)
  {
    for (int j = 0; j < _fNumPar; ++j)
    {
      InvertCovMatrix[i][j] = (*invCovMatrix)(i,j);
    }
  }
 
  SetThrowMatrix(cov);
}

SetFlatPrior()

void ParameterHandlerBase::SetFlatPrior	(	const int	i,
		const bool	eL
	)

Set if parameter should have flat prior or not.

Parameters

i	Parameter index
eL	bool telling if it will be flat or not

Definition at line 944 of file ParameterHandlerBase.cpp.

                                                                  {
// ********************************************
  if (i > _fNumPar) {
    MACH3LOG_INFO("Can't {} for Cov={}/Param={} because size of Covariance = {}", __func__, GetName(), i, _fNumPar);
    MACH3LOG_ERROR("Fix this in your config file please!");
    throw MaCh3Exception(__FILE__ , __LINE__ );
  } else {
    if(eL){
      MACH3LOG_INFO("Setting {} (parameter {}) to flat prior", GetParName(i), i);
    }
    else{
      // HW :: This is useful
      MACH3LOG_INFO("Setting {} (parameter {}) to non-flat prior", GetParName(i), i);
    }
    _fFlatPrior[i] = eL;
  }
}

SetGroupOnlyParameters() [1/2]

void ParameterHandlerGeneric::SetGroupOnlyParameters	(	const std::string &	Group,
		const std::vector< double > &	Pars = {}
	)

KS Function to set to prior parameters of a given group or values from vector.

Parameters

Group	name of group, like Xsec or Flux
Pars	Values which will overwrite proposed step

Note

this mimic functionality of @ParameterHandlerBaseSetParameters

Definition at line 675 of file ParameterHandlerGeneric.cpp.

                                                                                                          {
// ********************************************
  // If empty, set the proposed to prior
  if (Pars.empty()) {
    for (int i = 0; i < _fNumPar; i++) {
      if(IsParFromGroup(i, Group)) _fPropVal[i] = _fPreFitValue[i];
    }
  } else{
    const size_t ExpectedSize = static_cast<size_t>(GetNumParFromGroup(Group));
    if (Pars.size() != ExpectedSize) {
      MACH3LOG_ERROR("Number of param in group {} is {}, while you passed {}", Group, ExpectedSize, Pars.size());
      throw MaCh3Exception(__FILE__, __LINE__);
    }
    int Counter = 0;
    for (int i = 0; i < _fNumPar; i++) {
      // If belongs to group set value from parsed vector, otherwise use propose value
      if(IsParFromGroup(i, Group)){
        _fPropVal[i] = Pars[Counter];
        Counter++;
      }
    }
  }
  // And if pca make the transfer
  if (pca) {
    PCAObj->TransferToPCA();
    PCAObj->TransferToParam();
  }
}

SetGroupOnlyParameters() [2/2]

void ParameterHandlerGeneric::SetGroupOnlyParameters

(

const std::vector< std::string > &

Groups

)

KS Function to set to prior parameters of a given groups or values from vector.

Parameters

Group

vector of group names, like Xsec or Flux

Definition at line 666 of file ParameterHandlerGeneric.cpp.

                                                                                        {
// ********************************************
  for(size_t i = 0; i < Groups.size(); i++){
    SetGroupOnlyParameters(Groups[i]);
  }
}

SetIndivStepScale() [1/2]

void ParameterHandlerBase::SetIndivStepScale ( const int  ParameterIndex, const double  StepScale  )

inline

DB Function to set fIndivStepScale from a vector (Can be used from execs and inside covariance constructors)

Parameters

ParameterIndex	Parameter Index
StepScale	Value of individual step scale

Definition at line 106 of file ParameterHandlerBase.h.

{ _fIndivStepScale.at(ParameterIndex) = StepScale; }

SetIndivStepScale() [2/2]

void ParameterHandlerBase::SetIndivStepScale

(

const std::vector< double > &

stepscale

)

DB Function to set fIndivStepScale from a vector (Can be used from execs and inside covariance constructors)

Parameters

stepscale

Vector of individual step scale, should have same

Definition at line 963 of file ParameterHandlerBase.cpp.

                                                                               {
// ********************************************
  if (int(stepscale.size()) != _fNumPar)
  {
    MACH3LOG_WARN("Stepscale vector not equal to number of parameters. Quitting..");
    MACH3LOG_WARN("Size of argument vector: {}", stepscale.size());
    MACH3LOG_WARN("Expected size: {}", _fNumPar);
    return;
  }
 
  for (int iParam = 0 ; iParam < _fNumPar; iParam++) {
    _fIndivStepScale[iParam] = stepscale[iParam];
  }
  PrintIndivStepScale();
}

SetName()

void ParameterHandlerBase::SetName ( const std::string &  name )

inline

Set matrix name.

Definition at line 45 of file ParameterHandlerBase.h.

{ matrixName = name; }

SetNumberOfSteps()

void ParameterHandlerBase::SetNumberOfSteps ( const int  nsteps )

inline

Set number of MCMC step, when running adaptive MCMC it is updated with given frequency. We need number of steps to determine frequency.

Definition at line 204 of file ParameterHandlerBase.h.

                                                 {
    AdaptiveHandler->SetTotalSteps(nsteps);
    if(AdaptiveHandler->AdaptionUpdate()) ResetIndivStepScale();
  }

SetPar()

void ParameterHandlerBase::SetPar	(	const int	i,
		const double	val
	)

Set all the covariance matrix parameters to a user-defined value.

Parameters

i	Parameter index
val	new value which will be set

Definition at line 428 of file ParameterHandlerBase.cpp.

                                                    {
// ********************************************
  MACH3LOG_INFO("Over-riding {}: ", GetParName(i));
  MACH3LOG_INFO("_fPropVal ({}), _fCurrVal ({}), _fPreFitValue ({}) to ({})", _fPropVal[i], _fCurrVal[i], _fPreFitValue[i], val);
 
  _fPropVal[i] = val;
  _fCurrVal[i] = val;
  _fPreFitValue[i] = val;
 
  // Transfer the parameter values to the PCA basis
  if (pca) PCAObj->TransferToPCA();
}

SetParameters()

void ParameterHandlerBase::SetParameters

(

const std::vector< double > &

pars = {}

)

Set parameter values using vector, it has to have same size as covariance class.

Parameters

pars	Vector holding new values for every parameter

Definition at line 810 of file ParameterHandlerBase.cpp.

                                                                      {
// ********************************************
  // If empty, set the proposed to prior
  if (pars.empty()) {
    // For xsec this means setting to the prior (because prior is the prior)
    for (int i = 0; i < _fNumPar; i++) {
      _fPropVal[i] = _fPreFitValue[i];
    }
    // If not empty, set the parameters to the specified
  } else {
    if (pars.size() != size_t(_fNumPar)) {
      MACH3LOG_ERROR("Parameter arrays of incompatible size! Not changing parameters! {} has size {} but was expecting {}", matrixName, pars.size(), _fNumPar);
      throw MaCh3Exception(__FILE__ , __LINE__ );
    }
    int parsSize = int(pars.size());
    for (int i = 0; i < parsSize; i++) {
      //Make sure that you are actually passing a number to set the parameter to
      if(std::isnan(pars[i])) {
        MACH3LOG_ERROR("Trying to set parameter value to a nan for parameter {} in matrix {}. This will not go well!", GetParName(i), matrixName);
        throw MaCh3Exception(__FILE__ , __LINE__ );
      } else {
        _fPropVal[i] = pars[i];
      }
    }
  }
  // And if pca make the transfer
  if (pca) {
    PCAObj->TransferToPCA();
    PCAObj->TransferToParam();
  }
}

SetParametersPCA()

void PCAHandler::SetParametersPCA ( const std::vector< double > &  pars )

inline

Set values for PCA parameters in PCA base.

Parameters

pars	vector with new values of PCA params

Definition at line 101 of file PCAHandler.h.

                                                       {
    if (int(pars.size()) != NumParPCA) {
      MACH3LOG_ERROR("Parameter arrays of incompatible size! Not changing parameters! has size {} but was expecting {}", pars.size(), NumParPCA);
      throw MaCh3Exception(__FILE__ , __LINE__ );
    }
    int parsSize = int(pars.size());
    for (int i = 0; i < parsSize; i++) {
      _fParPropPCA(i) = pars[i];
    }
    //KS: Transfer to normal base
    TransferToParam();
  }

SetParCurrPCA()

void PCAHandler::SetParCurrPCA ( const int  i, const double  value  )

inline

Set current value for parameter in PCA base.

Parameters

i	Parameter index
value	new value

Definition at line 141 of file PCAHandler.h.

                                                      {
    _fParCurrPCA(i) = value;
    // And then transfer back to the parameter basis
    TransferToParam();
  }

SetParCurrProp()

void ParameterHandlerBase::SetParCurrProp	(	const int	i,
		const double	val
	)

Set current parameter value.

Parameters

i	Parameter index
val	new value which will be set

Definition at line 551 of file ParameterHandlerBase.cpp.

                                                                              {
// ********************************************
  _fPropVal[parNo] = parVal;
  _fCurrVal[parNo] = parVal;
  MACH3LOG_DEBUG("Setting {} (parameter {}) to {})", GetParName(parNo),  parNo, parVal);
  if (pca) PCAObj->TransferToPCA();
}

SetParName()

void ParameterHandlerBase::SetParName ( const int  i, const std::string &  name  )

inline

change parameter name

Parameters

i	Parameter index
name	new name which will be set

Definition at line 50 of file ParameterHandlerBase.h.

{ _fNames.at(i) = name; }

SetParProp()

void ParameterHandlerBase::SetParProp ( const int  i, const double  val  )

inline

Set proposed parameter value.

Parameters

i	Parameter index
val	new value which will be set

Definition at line 68 of file ParameterHandlerBase.h.

                                                 {
    _fPropVal[i] = val;
    if (pca) PCAObj->TransferToPCA();
  }

SetParPropPCA()

void PCAHandler::SetParPropPCA ( const int  i, const double  value  )

inline

Set proposed value for parameter in PCA base.

Parameters

i	Parameter index
value	new value

Definition at line 132 of file PCAHandler.h.

                                                      {
    _fParPropPCA(i) = value;
    // And then transfer back to the parameter basis
    TransferToParam();
  }

SetPrintLength()

void ParameterHandlerBase::SetPrintLength ( const unsigned int  PriLen )

inline

KS: In case someone really want to change this.

Definition at line 113 of file ParameterHandlerBase.h.

{ PrintLength = PriLen; }

SetRandomThrow()

void ParameterHandlerBase::SetRandomThrow ( const int  i, const double  rand  )

inline

Set random value useful for debugging/CI.

Parameters

i	Parameter index
rand	New value for random number

Definition at line 86 of file ParameterHandlerBase.h.

{ randParams[i] = rand;}

SetSingleParameter()

void ParameterHandlerBase::SetSingleParameter	(	const int	parNo,
		const double	parVal
	)

Set value of single param to a given value.

Definition at line 542 of file ParameterHandlerBase.cpp.

                                                                                  {
// *************************************
  _fPropVal[parNo] = parVal;
  _fCurrVal[parNo] = parVal;
  MACH3LOG_DEBUG("Setting {} (parameter {}) to {})", GetParName(parNo),  parNo, parVal);
  if (pca) PCAObj->TransferToPCA();
}

SetStepScale()

void ParameterHandlerBase::SetStepScale

(

const double

scale

)

Set global step scale for covariance object.

Parameters

scale

Value of global step scale [20]

Definition at line 863 of file ParameterHandlerBase.cpp.

                                                          {
// ********************************************
  if(scale <= 0) {
    MACH3LOG_ERROR("You are trying so set StepScale to 0 or negative this will not work");
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
  MACH3LOG_INFO("{} setStepScale() = {}", GetName(), scale);
  const double SuggestedScale = 2.38*2.38/_fNumPar;
  if(std::fabs(scale - SuggestedScale)/SuggestedScale > 1) {
    MACH3LOG_WARN("Defined Global StepScale is {}, while suggested suggested {}", scale, SuggestedScale);
  }
 
  _fGlobalStepScale = scale;
}

SetThrowMatrix()

void ParameterHandlerBase::SetThrowMatrix

(

TMatrixDSym *

cov

)

Use new throw matrix, used in adaptive MCMC.

Definition at line 1050 of file ParameterHandlerBase.cpp.

                                                         {
// ********************************************
   if (cov == nullptr) {
    MACH3LOG_ERROR("Could not find covariance matrix you provided to {}", __func__);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  if (covMatrix->GetNrows() != cov->GetNrows()) {
    MACH3LOG_ERROR("Matrix given for throw Matrix is not the same size as the covariance matrix stored in object!");
    MACH3LOG_ERROR("Stored covariance matrix size: {}", covMatrix->GetNrows());
    MACH3LOG_ERROR("Given matrix size: {}", cov->GetNrows());
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  throwMatrix = static_cast<TMatrixDSym*>(cov->Clone());
  if(use_adaptive && AdaptiveHandler->AdaptionUpdate()) MakeClosestPosDef(throwMatrix);
  else MakePosDef(throwMatrix);
  
  TDecompChol TDecompChol_throwMatrix(*throwMatrix);
  
  if(!TDecompChol_throwMatrix.Decompose()) {
    MACH3LOG_ERROR("Cholesky decomposition failed for {} trying to make positive definite", matrixName);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  throwMatrix_CholDecomp = new TMatrixD(TDecompChol_throwMatrix.GetU());
  throwMatrix_CholDecomp->T();
 
  //KS: ROOT has bad memory management, using standard double means we can decrease most operation by factor 2 simply due to cache hits
  #ifdef MULTITHREAD
  #pragma omp parallel for collapse(2)
  #endif
  for (int i = 0; i < _fNumPar; ++i)
  {
    for (int j = 0; j < _fNumPar; ++j)
    {
      throwMatrixCholDecomp[i][j] = (*throwMatrix_CholDecomp)(i,j);
    }
  }
}

SetTune()

void ParameterHandlerBase::SetTune

(

const std::string &

TuneName

)

KS: Set proposed parameter values vector to be base on tune values, for example set proposed values to be of generated or maybe PostND.

Definition at line 1311 of file ParameterHandlerBase.cpp.

                                                            {
// ********************************************
  if(Tunes == nullptr) {
    MACH3LOG_ERROR("Tunes haven't been initialised, which are being loaded from YAML, have you used some deprecated constructor");
    throw MaCh3Exception(__FILE__, __LINE__);
  }
  auto Values = Tunes->GetTune(TuneName);
 
  SetParameters(Values);
}

ToggleFixAllParameters()

void PCAHandler::ToggleFixAllParameters

(

)

fix parameters at prior values

Definition at line 327 of file PCAHandler.cpp.

                                        {
// ********************************************
  for (int i = 0; i < NumParPCA; i++) {
    _fErrorPCA[i] *= -1.0;
  }
}

ToggleFixParameter()

void PCAHandler::ToggleFixParameter	(	const int	i,
		const std::vector< std::string > &	Names
	)

fix parameters at prior values

Definition at line 335 of file PCAHandler.cpp.

                                                                                  {
// ********************************************
  int isDecom = -1;
  for (int im = 0; im < NumParPCA; ++im) {
    if(isDecomposedPCA[im] == i) {isDecom = im;}
  }
  if(isDecom < 0) {
    MACH3LOG_ERROR("Parameter {} is PCA decomposed can't fix this", Names[i]);
    //throw MaCh3Exception(__FILE__ , __LINE__ );
  } else {
    _fErrorPCA[isDecom] *= -1.0;
    MACH3LOG_INFO("Setting un-decomposed {}(parameter {}/{} in PCA base) to fixed at {}", Names[i], i, isDecom, (*_pCurrVal)[i]);
  }
}