ParameterHandlerGeneric Class Reference

Class responsible for handling of systematic error parameters with different types defined in the config. Like spline, normalisation parameters etc. More...

#include <Parameters/ParameterHandlerGeneric.h>

Inheritance diagram for ParameterHandlerGeneric:

Collaboration diagram for ParameterHandlerGeneric:

Public Member Functions
	ParameterHandlerGeneric (const std::vector< std::string > &FileNames, std::string name="xsec_cov", double threshold=-1, int FirstPCAdpar=-999, int LastPCAdpar=-999)
	Constructor. More...
	~ParameterHandlerGeneric ()
	Destructor. More...
std::vector< std::string >	GetParSampleID (const int i) const
	ETA - just return the int of the SampleName, this can be removed to do a string comp at some point. More...
std::string	GetParamTypeString (const int i) const
	ETA - just return a string of "spline", "norm" or "functional". More...
SystType	GetParamType (const int i) const
	Returns enum describing our param type. More...
SplineInterpolation	GetParSplineInterpolation (const int i) const
	Get interpolation type for a given parameter. More...
const std::vector< SplineInterpolation >	GetSplineInterpolationFromSampleName (const std::string &SampleName) const
	Get the interpolation types for splines affecting a particular SampleName. More...
std::string	GetParSplineName (const int i) const
	Get the name of the spline associated with the spline at index i. More...
const std::vector< int >	GetGlobalSystIndexFromSampleName (const std::string &SampleName, const SystType Type) const
	DB Get spline parameters depending on given SampleName. More...
double	GetParSplineKnotUpperBound (const int i) const
	EM: value at which we cap spline knot weight. More...
double	GetParSplineKnotLowerBound (const int i) const
	EM: value at which we cap spline knot weight. More...
int	GetNumParamsFromSampleName (const std::string &SampleName, const SystType Type) const
	DB Grab the number of parameters for the relevant SampleName. More...
const std::vector< std::string >	GetParsNamesFromSampleName (const std::string &SampleName, const SystType Type) const
	DB Grab the parameter names for the relevant SampleName. More...
const std::vector< int >	GetParsIndexFromSampleName (const std::string &SampleName, const SystType Type) const
	DB Grab the parameter indices for the relevant SampleName. More...
const std::vector< std::string >	GetSplineParsNamesFromSampleName (const std::string &SampleName) const
	DB Get spline parameters depending on given SampleName. More...
const std::vector< std::string >	GetSplineFileParsNamesFromSampleName (const std::string &SampleName) const
	DB Get spline parameters depending on given SampleName. More...
const std::vector< std::vector< int > >	GetSplineModeVecFromSampleName (const std::string &SampleName) const
	DB Grab the Spline Modes for the relevant SampleName. More...
const std::vector< int >	GetSystIndexFromSampleName (const std::string &SampleName, const SystType Type) const
	Grab the index of the syst relative to global numbering. More...
const std::vector< NormParameter >	GetNormParsFromSampleName (const std::string &SampleName) const
	DB Get norm/func parameters depending on given SampleName. More...
const std::vector< FunctionalParameter >	GetFunctionalParametersFromSampleName (const std::string &SampleName) const
	HH Get functional parameters for the relevant SampleName. More...
const std::vector< SplineParameter >	GetSplineParsFromSampleName (const std::string &SampleName) const
	KS: Grab the Spline parameters for the relevant SampleName. More...
bool	IsParFromGroup (const int i, const std::string &Group) const
	Checks if parameter belongs to a given group. More...
int	GetNumParFromGroup (const std::string &Group) const
	KS: Check how many parameters are associated with given group. More...
std::vector< std::string >	GetUniqueParameterGroups () const
	KS: Get names of all unique parameter groups. More...
void	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. More...
void	SetGroupOnlyParameters (const std::vector< std::string > &Groups)
	KS Function to set to prior parameters of a given groups or values from vector. More...
void	SetFixGroupOnlyParameters (const std::string &Group)
	TN Method to set parameters within a group to be fixed to their prior values. More...
void	SetFixGroupOnlyParameters (const std::vector< std::string > &Groups)
	TN Method to set parameters of certain groups to be fixed to their prior values. More...
void	SetFreeGroupOnlyParameters (const std::string &Group)
	TN Method to set parameters within a group to be treated as free. More...
void	SetFreeGroupOnlyParameters (const std::vector< std::string > &Groups)
	TN Method to set parameters of certain groups to be treated as free. More...
void	DumpMatrixToFile (const std::string &Name)
	Dump Matrix to ROOT file, useful when we need to pass matrix info to another fitting group. More...
std::vector< const M3::float_t * >	GetOscParsFromSampleName (const std::string &SampleName) const
	Get pointers to Osc params from Sample name. More...
Public Member Functions inherited from ParameterHandlerBase
	ParameterHandlerBase (std::string name, std::string file, double threshold=-1, int FirstPCAdpar=-999, int LastPCAdpar=-999)
	"Usual" constructors from root file More...
	ParameterHandlerBase ()=default
virtual	~ParameterHandlerBase ()
	Destructor. More...
void	SetCovMatrix (TMatrixDSym *cov)
	Set covariance matrix. More...
void	SetName (const std::string &name)
	Set matrix name. More...
void	SetParName (const int i, const std::string &name)
	change parameter name More...
void	SetSingleParameter (const int parNo, const double parVal)
	Set value of single param to a given value. More...
void	SetPar (const int i, const double val)
	Set all the covariance matrix parameters to a user-defined value. More...
void	SetParCurrProp (const int i, const double val)
	Set current parameter value. More...
void	SetParProp (const int i, const double val)
	Set proposed parameter value. More...
void	SetParameters (const std::vector< double > &pars={})
	Set parameter values using vector, it has to have same size as covariance class. More...
void	SetFlatPrior (const int i, const bool eL)
	Set if parameter should have flat prior or not. More...
void	SetRandomThrow (const int i, const double rand)
	Set random value useful for debugging/CI. More...
double	GetRandomThrow (const int i) const
	Get random value useful for debugging/CI. More...
void	SetBranches (TTree &tree, const bool SaveProposal=false)
	set branches for output file More...
void	SetStepScale (const double scale, const bool verbose=true)
	Set global step scale for covariance object. More...
void	SetIndivStepScale (const int ParameterIndex, const double StepScale)
	DB Function to set fIndivStepScale from a vector (Can be used from execs and inside covariance constructors) More...
void	SetIndivStepScale (const std::vector< double > &stepscale)
	DB Function to set fIndivStepScale from a vector (Can be used from execs and inside covariance constructors) More...
void	SetPrintLength (const unsigned int PriLen)
	KS: In case someone really want to change this. More...
void	SaveUpdatedMatrixConfig ()
	KS: After step scale, prefit etc. value were modified save this modified config. More...
void	ThrowParameters ()
	Throw the parameters according to the covariance matrix. This shouldn't be used in MCMC code ase it can break Detailed Balance;. More...
void	RandomConfiguration ()
	Randomly throw the parameters in their 1 sigma range. More...
int	CheckBounds () const _noexcept_
	Check if parameters were proposed outside physical boundary. More...
double	CalcLikelihood () const _noexcept_
	Calc penalty term based on inverted covariance matrix. More...
virtual double	GetLikelihood ()
	Return CalcLikelihood if some params were thrown out of boundary return LARGE_LOGL More...
TMatrixDSym *	GetCovMatrix () const
	Return covariance matrix. More...
TMatrixDSym *	GetInvCovMatrix () const
	Return inverted covariance matrix. More...
double	GetInvCovMatrix (const int i, const int j) const
	Return inverted covariance matrix. More...
double	GetCorrThrows (const int i) const
	Return correlated throws. More...
bool	GetFlatPrior (const int i) const
	Get if param has flat prior or not. More...
std::string	GetName () const
	Get name of covariance. More...
std::string	GetParName (const int i) const
	Get name of parameter. More...
int	GetParIndex (const std::string &name) const
	Get index based on name. More...
std::string	GetParFancyName (const int i) const
	Get fancy name of the Parameter. More...
double	GetDiagonalError (const int i) const
	Get diagonal error for ith parameter. More...
double	GetError (const int i) const
	Get the error for the ith parameter. More...
void	ResetIndivStepScale ()
	Adaptive Step Tuning Stuff. More...
void	SetIndivStepScaleForSkippedAdaptParams ()
	Set individual step scale for parameters which are skipped during adaption to initial values. More...
void	InitialiseAdaption (const YAML::Node &adapt_manager)
	Initialise adaptive MCMC. More...
void	SaveAdaptiveToFile (const std::string &outFileName, const std::string &systematicName)
	Save adaptive throw matrix to file. More...
bool	GetDoAdaption () const
	Do we adapt or not. More...
void	SetThrowMatrix (const TMatrixDSym *cov)
	Use new throw matrix, used in adaptive MCMC. More...
void	SetSubThrowMatrix (int first_index, int last_index, TMatrixDSym const &subcov)
void	UpdateThrowMatrix (TMatrixDSym *cov)
	Replaces old throw matrix with new one. More...
void	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. More...
TMatrixDSym *	GetThrowMatrix () const
	Get matrix used for step proposal. More...
double	GetThrowMatrix (const int i, const int j) const
	Get matrix used for step proposal. More...
TH2D *	GetCorrelationMatrix () const
	KS: Convert covariance matrix to correlation matrix and return TH2D which can be used for fancy plotting. More...
const M3::float_t *	RetPointer (const int iParam) const
	DB Pointer return to param position. More...
const std::vector< M3::float_t > &	GetParPropVec ()
	Get a reference to the proposed parameter values Can be useful if you want to track these without having to copy values using getProposed() More...
int	GetNumParams () const
	Get total number of parameters. More...
std::vector< double >	GetPreFitValues () const
	Get the pre-fit values of the parameters. More...
std::vector< double >	GetProposed () const
	Get vector of all proposed parameter values. More...
M3::float_t	GetParProp (const int i) const
	Get proposed parameter value. More...
double	GetParCurr (const int i) const
	Get current parameter value. More...
const std::vector< double > &	GetParCurrVec () const
	Get vector of current parameter values. More...
double	GetParPreFit (const int i) const
	Get prior parameter value. More...
double	GetUpperBound (const int i) const
	Get upper parameter bound in which it is physically valid. More...
double	GetLowerBound (const int i) const
	Get lower parameter bound in which it is physically valid. More...
double	GetIndivStepScale (const int ParameterIndex) const
	Get individual step scale for selected parameter. More...
double	GetGlobalStepScale () const
	Get global step scale for covariance object. More...
int	GetNParameters () const
	Get number of params which will be different depending if using Eigen decomposition or not. More...
void	PrintPreFitValues () const
	Print prior value for every parameter. More...
void	PrintPreFitCurrPropValues () const
	Print prior, current and proposed value for each parameter. More...
void	PrintIndivStepScale () const
	Print step scale for each parameter. More...
virtual void	ProposeStep ()
	Generate a new proposed state. More...
void	Randomize () _noexcept_
	"Randomize" the parameters in the covariance class for the proposed step. Used the proposal kernel and the current parameter value to set proposed step More...
void	CorrelateSteps () _noexcept_
	Use Cholesky throw matrix for better step proposal. More...
void	UpdateAdaptiveCovariance ()
	Method to update adaptive MCMC [15]. More...
void	AcceptStep () _noexcept_
	Accepted this step. More...
void	SetFixAllParameters ()
	Set all parameters to be fixed at prior values. More...
void	SetFixParameter (const int i)
	Set parameter to be fixed at prior value. More...
void	SetFixParameter (const std::string &name)
	Set parameter to be fixed at prior value. More...
void	SetFreeAllParameters ()
	Set all parameters to be treated as free. More...
void	SetFreeParameter (const int i)
	Set parameter to be treated as free. More...
void	SetFreeParameter (const std::string &name)
	Set parameter to be treated as free. More...
bool	IsParameterFixed (const int i) const
	Is parameter fixed or not. More...
bool	IsParameterFixed (const std::string &name) const
	Is parameter fixed or not. More...
void	ConstructPCA (const double eigen_threshold, int FirstPCAdpar, int LastPCAdpar)
	CW: Calculate eigen values, prepare transition matrices and remove param based on defined threshold. More...
bool	IsPCA () const
	is PCA, can use to query e.g. LLH scans More...
YAML::Node	GetConfig () const
	Getter to return a copy of the YAML node. More...
AdaptiveMCMCHandler *	GetAdaptiveHandler () const
	Get pointer for AdaptiveHandler. More...
void	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. More...
PCAHandler *	GetPCAHandler () const
	Get pointer for PCAHandler. More...
void	MatchMaCh3OutputBranches (TTree *PosteriorFile, std::vector< double > &BranchValues, std::vector< std::string > &BranchNames, const std::vector< std::string > &FancyNames={})
	Matches branches in a TTree to parameters in a systematic handler. More...

Protected Member Functions
void	InitialiseFromConfig (const std::vector< std::string > &YAMLFile)
	Initialisation of the class using config. More...
void	Print () const
	Print information about the whole object once it is set. More...
void	PrintGlobablInfo () const
	Prints general information about the ParameterHandler object. More...
void	PrintNormParams () const
	Prints normalization parameters. More...
void	PrintSplineParams () const
	Prints spline parameters. More...
void	PrintFunctionalParams () const
	Prints functional parameters. More...
void	PrintOscillationParams () const
	Prints oscillation parameters. More...
void	PrintParameterGroups () const
	Prints groups of parameters. More...
void	CheckCorrectInitialisation () const
	KS: Check if matrix is correctly initialised. More...
void	LoadCorrelationFromConfig (std::vector< std::map< std::string, double >> &Correlations, std::map< std::string, int > &CorrNamesMap)
	Load correlation from yaml config. More...
void	LoadAndMergeYAML (const std::vector< std::string > &YAMLFile, std::map< std::pair< int, int >, std::unique_ptr< TMatrixDSym >> &overrides)
	Initialise single yaml based on several yaml files. More...
template<typename FilterFunc , typename ActionFunc >
void	IterateOverParams (const std::string &SampleName, FilterFunc filter, ActionFunc action) const
	Iterates over parameters and applies a filter and action function. More...
void	InitParameters ()
	Initializes the systematic parameters from the configuration file. This function loads parameters like normalizations and splines from the provided YAML file. More...
void	InitParametersTypeFromConfig ()
	Parses the YAML configuration to set up cross-section parameters. The YAML file defines the types of systematic errors, interpolation types, and bounds for splines. More...
NormParameter	GetNormParameter (const YAML::Node &param, const int Index) const
	Get Norm params. More...
OscillationParameter	GetOscillationParameters (const YAML::Node &param, const int Index) const
	Get Osc params. More...
FunctionalParameter	GetFunctionalParameters (const YAML::Node &param, const int Index) const
	Get Func params. More...
SplineParameter	GetSplineParameter (const YAML::Node &param, const int Index) const
	Get Spline params. More...
void	GetBaseParameter (const YAML::Node &param, const int Index, TypeParameterBase &Parameter) const
	Fill base parameters. More...
bool	AppliesToSample (const int SystIndex, const std::string &SampleName) const
	Check if parameter is affecting given sample name. More...
template<typename ParamT >
std::vector< ParamT >	GetTypeParamsFromSampleName (const std::map< int, int > &indexMap, const std::vector< ParamT > &params, const std::string &SampleName) const
	Retrieve parameters that apply to a given sample name. More...
Protected Member Functions inherited from ParameterHandlerBase
void	InitFromFile (const std::string &name, const std::string &file)
	Initialisation of the class using matrix from root file. More...
void	ReserveMemory (const int size)
	Initialise vectors with parameters information. More...
void	MakePosDef (TMatrixDSym *cov=nullptr, bool verbose=true)
	Make matrix positive definite by adding small values to diagonal, necessary for inverting matrix. More...
void	MakeClosestPosDef (TMatrixDSym *cov)
	HW: Finds closest possible positive definite matrix in Frobenius Norm ||.||_frob Where ||X||_frob=sqrt[sum_ij(x_ij^2)] (basically just turns an n,n matrix into vector in n^2 space then does Euclidean norm) More...
void	SetThrowMatrixFromFile (const std::string &matrix_file_name, const std::string &matrix_name, const std::string &means_name)
	sets throw matrix from a file More...
void	SanitizeAdaption () const
	Perform sanity check to ensure adaption isn't misbehaving before fit starts. More...
void	FlipParameterValue (const int index, const double FlipPoint)
	KS: Flip parameter around given value, for example mass ordering around 0. More...
void	CircularParBounds (const int i, const double LowBound, const double UpBound)
	HW :: This method is a tad hacky but modular arithmetic gives me a headache. More...
void	EnableSpecialProposal (const YAML::Node &param, const int Index)
	Enable special proposal. More...
void	SpecialStepProposal ()
	Perform Special Step Proposal. More...

Protected Attributes
std::vector< std::vector< std::string > >	_fSampleNames
	Tells to which samples object param should be applied. More...
std::vector< SystType >	_fParamType
	Type of parameter like norm, spline etc. More...
std::vector< std::string >	_ParameterGroup
	KS: Allow to group parameters for example to affect only cross-section or only flux etc. More...
std::vector< std::map< int, int > >	_fSystToGlobalSystIndexMap
	Map between number of given parameter type with global parameter numbering. For example 2nd norm param may be 10-th global param. More...
std::vector< SplineParameter >	SplineParams
	Vector containing info for normalisation systematics. More...
std::vector< NormParameter >	NormParams
	Vector containing info for normalisation systematics. More...
std::vector< FunctionalParameter >	FuncParams
	Vector containing info for functional systematics. More...
std::vector< OscillationParameter >	OscParams
	Vector containing info for functional systematics. More...
Protected Attributes inherited from ParameterHandlerBase
bool	doSpecialStepProposal
	Check if any of special step proposal were enabled. More...
std::string	inputFile
	The input root file we read in. More...
std::string	matrixName
	Name of cov matrix. More...
TMatrixDSym *	covMatrix
	The covariance matrix. More...
TMatrixDSym *	invCovMatrix
	The inverse covariance matrix. More...
std::vector< std::vector< double > >	InvertCovMatrix
	KS: Same as above but much faster as TMatrixDSym cache miss. More...
std::vector< std::unique_ptr< TRandom3 > >	random_number
	KS: Set Random numbers for each thread so each thread has different seed. More...
double *	randParams
	Random number taken from gaussian around prior error used for corr_throw. More...
double *	corr_throw
	Result of multiplication of Cholesky matrix and randParams. More...
double	_fGlobalStepScale
	Global step scale applied to all params in this class. More...
int	PrintLength
	KS: This is used when printing parameters, sometimes we have super long parameters name, we want to flexibly adjust couts. More...
std::vector< std::string >	_fNames
	ETA _fNames is set automatically in the covariance class to be something like param_i, this is currently to make things compatible with the Diagnostic tools. More...
std::vector< std::string >	_fFancyNames
	Fancy name for example rather than param_0 it is MAQE, useful for human reading. More...
YAML::Node	_fYAMLDoc
	Stores config describing systematics. More...
int	_fNumPar
	Number of systematic parameters. More...
std::vector< double >	_fPreFitValue
	Parameter value dictated by the prior model. Based on it penalty term is calculated. More...
std::vector< double >	_fCurrVal
	Current value of the parameter. More...
std::vector< M3::float_t >	_fPropVal
	Proposed value of the parameter. More...
std::vector< double >	_fError
	Prior error on the parameter. More...
std::vector< double >	_fLowBound
	Lowest physical bound, parameter will not be able to go beyond it. More...
std::vector< double >	_fUpBound
	Upper physical bound, parameter will not be able to go beyond it. More...
std::vector< double >	_fIndivStepScale
	Individual step scale used by MCMC algorithm. More...
std::vector< bool >	_fFlatPrior
	Whether to apply flat prior or not. More...
std::vector< double >	_fIndivStepScaleInitial
	Backup of _fIndivStepScale for parameters which are skipped during adaption. More...
double	_fGlobalStepScaleInitial
	Backup of _fGlobalStepScale for parameters which are skipped during adaption. More...
std::vector< bool >	param_skip_adapt_flags
	Flags telling if parameter should be skipped during adaption. More...
TMatrixDSym *	throwMatrix
	Matrix which we use for step proposal before Cholesky decomposition (not actually used for step proposal) More...
double **	throwMatrixCholDecomp
	Throw matrix that is being used in the fit, much faster as TMatrixDSym cache miss. More...
bool	pca
	perform PCA or not More...
bool	use_adaptive
	Are we using AMCMC? More...
std::unique_ptr< PCAHandler >	PCAObj
	Struct containing information about PCA. More...
std::unique_ptr< AdaptiveMCMCHandler >	AdaptiveHandler
	Struct containing information about adaption. More...
std::unique_ptr< ParameterTunes >	Tunes
	Struct containing information about adaption. More...
std::vector< int >	FlipParameterIndex
	Indices of parameters with flip symmetry. More...
std::vector< double >	FlipParameterPoint
	Central points around which parameters are flipped. More...
std::vector< int >	CircularBoundsIndex
	Indices of parameters with circular bounds. More...
std::vector< std::pair< double, double > >	CircularBoundsValues
	Circular bounds for each parameter (lower, upper) More...

Detailed Description

Class responsible for handling of systematic error parameters with different types defined in the config. Like spline, normalisation parameters etc.

Author

Dan Barrow

Ed Atkin

Kamil Skwarczynski

Definition at line 14 of file ParameterHandlerGeneric.h.

Constructor & Destructor Documentation

ParameterHandlerGeneric()

ParameterHandlerGeneric::ParameterHandlerGeneric	(	const std::vector< std::string > &	FileNames,
		std::string	name = "xsec_cov",
		double	threshold = -1,
		int	FirstPCAdpar = -999,
		int	LastPCAdpar = -999
	)

Constructor.

Parameters

FileNames	A vector of strings representing the YAML files used for initialisation of matrix
name	Matrix name
threshold	PCA threshold from 0 to 1. Default is -1 and means no PCA
FirstPCAdpar	First PCA parameter that will be decomposed.
LastPCAdpar	First PCA parameter that will be decomposed.

Definition at line 7 of file ParameterHandlerGeneric.cpp.

                                                                                              {
// ********************************************
  MACH3LOG_INFO("Constructing instance of ParameterHandler using");
  inputFile = YAMLFile[0];
  matrixName = name;
  pca = true;
 
  doSpecialStepProposal = false;
  // Not using adaptive by default
  use_adaptive = false;
  for(unsigned int i = 0; i < YAMLFile.size(); i++)
  {
    MACH3LOG_INFO("{}", YAMLFile[i]);
  }
  MACH3LOG_INFO("as an input");
 
  if (threshold < 0 || threshold >= 1) {
    MACH3LOG_INFO("Principal component analysis but given the threshold for the principal components to be less than 0, or greater than (or equal to) 1. This will not work");
    MACH3LOG_INFO("Please specify a number between 0 and 1");
    MACH3LOG_INFO("You specified: ");
    MACH3LOG_INFO("Am instead calling the usual non-PCA constructor...");
    pca = false;
  }
 
  InitialiseFromConfig(YAMLFile);
  // Call the innocent helper function
  if (pca) ConstructPCA(threshold, FirstPCA, LastPCA);
 
  InitParametersTypeFromConfig();
 
  //ETA - again this really doesn't need to be hear...
  for (int i = 0; i < _fNumPar; i++)
  {
    // Sort out the print length
    if(int(_fNames[i].length()) > PrintLength) PrintLength = int(_fNames[i].length());
  } // end the for loop
 
  MACH3LOG_DEBUG("Constructing instance of ParameterHandler");
  InitParameters();
  // Print
  Print();
}

~ParameterHandlerGeneric()

ParameterHandlerGeneric::~ParameterHandlerGeneric

(

)

Destructor.

Definition at line 356 of file ParameterHandlerGeneric.cpp.

                                                  {
// ********************************************
  MACH3LOG_DEBUG("Deleting ParameterHandler");
}

Member Function Documentation

AppliesToSample()

bool ParameterHandlerGeneric::AppliesToSample ( const int  SystIndex, const std::string &  SampleName  ) const

protected

Check if parameter is affecting given sample name.

Parameters

SystIndex	number of parameter
SampleName	The Sample name used to filter parameters.

Definition at line 539 of file ParameterHandlerGeneric.cpp.

                                                                                                    {
// ********************************************
  // Empty means apply to all
  if (_fSampleNames[SystIndex].size() == 0) return true;
 
  // Check for unsupported wildcards in SampleName
  if (SampleName.find('*') != std::string::npos) {
    MACH3LOG_ERROR("Wildcards ('*') are not supported in sample name: '{}'", SampleName);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
  return M3::CaseInsensitiveMatchAny(SampleName, _fSampleNames[SystIndex]);
}

CheckCorrectInitialisation()

void ParameterHandlerGeneric::CheckCorrectInitialisation ( ) const

protected

KS: Check if matrix is correctly initialised.

Definition at line 896 of file ParameterHandlerGeneric.cpp.

                                                               {
// ********************************************
  // KS: Lambda Function which simply checks if there are no duplicates in std::vector
  auto CheckForDuplicates = [](const std::vector<std::string>& names, const std::string& nameType, bool Warning) {
    std::unordered_map<std::string, size_t> seenStrings;
    for (size_t i = 0; i < names.size(); ++i) {
      const auto& name = names[i];
      if (seenStrings.find(name) != seenStrings.end()) {
        size_t firstIndex = seenStrings[name];
        if(Warning){
          MACH3LOG_WARN("There are two systematics with the same {} '{}', first at index {}, and again at index {}", nameType, name, firstIndex, i);
          MACH3LOG_WARN("Is this desired?");
          return;
        } else {
          MACH3LOG_CRITICAL("There are two systematics with the same {} '{}', first at index {}, and again at index {}", nameType, name, firstIndex, i);
          throw MaCh3Exception(__FILE__, __LINE__);
        }
      }
      seenStrings[name] = i;
    }
  };
  std::vector<std::string> SplineNameTemp(SplineParams.size());
  for(size_t it = 0; it < SplineParams.size(); it++){
    SplineNameTemp[it] = SplineParams[it]._fSplineNames;
  }
  // KS: Checks if there are no duplicates in fancy names etc, this can happen if we merge configs etc
  CheckForDuplicates(_fFancyNames, "_fFancyNames", false);
  CheckForDuplicates(SplineNameTemp, "_fSplineNames", true);
}

DumpMatrixToFile()

void ParameterHandlerGeneric::DumpMatrixToFile

(

const std::string &

Name

)

Dump Matrix to ROOT file, useful when we need to pass matrix info to another fitting group.

Parameters

Name	Name of TFile to which we save stuff

Warning

This is mostly used for backward compatibility

Definition at line 1041 of file ParameterHandlerGeneric.cpp.

                                                                    {
// ********************************************
  // KS: Ideally we remove it eventually...
  TH2D* CorrMatrix = GetCorrelationMatrix();
  M3::DumpParamHandlerToFile(_fNumPar,
                             _fPreFitValue,
                             _fError,
                             _fLowBound,
                             _fUpBound,
                             _fIndivStepScale,
                             _fFancyNames,
                             _fFlatPrior,
                             SplineParams,
                             covMatrix,
                             CorrMatrix,
                             Name);
  delete CorrMatrix;
  MACH3LOG_INFO("Finished dumping ParameterHandler object");
}

GetBaseParameter()

void ParameterHandlerGeneric::GetBaseParameter ( const YAML::Node &  param, const int  Index, TypeParameterBase &  Parameter  ) const

protected

Fill base parameters.

Parameters

param	Yaml node describing param
Index	Global parameter index
Parameter	Object storing info

Definition at line 435 of file ParameterHandlerGeneric.cpp.

                                                                                                                         {
// ********************************************
  Parameter.name = GetParFancyName(Index);
 
  // Set the global parameter index of the normalisation parameter
  Parameter.index = Index;
 
  int NumKinematicCuts = 0;
  if(param["KinematicCuts"]) {
    NumKinematicCuts = int(param["KinematicCuts"].size());
 
    std::vector<std::string> TempKinematicStrings;
    std::vector<std::vector<std::vector<double>>> TempKinematicBounds;
    //First element of TempKinematicBounds is always -999, and size is then 3
    for(int KinVar_i = 0 ; KinVar_i < NumKinematicCuts ; ++KinVar_i) {
      //ETA: This is a bit messy, Kinematic cuts is a list of maps
      for (YAML::const_iterator it = param["KinematicCuts"][KinVar_i].begin();it!=param["KinematicCuts"][KinVar_i].end();++it) {
        TempKinematicStrings.push_back(it->first.as<std::string>());
        TempKinematicBounds.push_back(Get2DBounds(it->second));
      }
      if(TempKinematicStrings.size() == 0) {
        MACH3LOG_ERROR("Received a KinematicCuts node but couldn't read the contents (it's a list of single-element dictionaries (python) = map of pairs (C++))");
        MACH3LOG_ERROR("For Param {}", Parameter.name);
        throw MaCh3Exception(__FILE__, __LINE__);
      }
    }//KinVar_i
    Parameter.KinematicVarStr = TempKinematicStrings;
    Parameter.Selection = TempKinematicBounds;
  }
 
  //Next ones are kinematic bounds on where normalisation parameter should apply
  //We set a bool to see if any bounds exist so we can short-circuit checking all of them every step
  bool HasKinBounds = false;
 
  if(Parameter.KinematicVarStr.size() > 0) HasKinBounds = true;
 
  Parameter.hasKinBounds = HasKinBounds;
  //End of kinematic bound checking
}

GetFunctionalParameters()

FunctionalParameter ParameterHandlerGeneric::GetFunctionalParameters ( const YAML::Node &  param, const int  Index  ) const

protected

Get Func params.

Parameters

param	Yaml node describing param
Index	Global parameter index

Definition at line 554 of file ParameterHandlerGeneric.cpp.

                                                                                                                 {
// ********************************************
  FunctionalParameter func;
  GetBaseParameter(param, Index, func);
 
  func.modes = GetFromManager<std::vector<int>>(param["Mode"], std::vector<int>(), __FILE__ , __LINE__);
 
  return func;
}

GetFunctionalParametersFromSampleName()

const std::vector< FunctionalParameter > ParameterHandlerGeneric::GetFunctionalParametersFromSampleName

(

const std::string &

SampleName

)

const

HH Get functional parameters for the relevant SampleName.

Definition at line 576 of file ParameterHandlerGeneric.cpp.

                                                                                                                                     {
// ********************************************
  return GetTypeParamsFromSampleName(_fSystToGlobalSystIndexMap[SystType::kFunc], FuncParams, SampleName);
}

GetGlobalSystIndexFromSampleName()

const std::vector< int > ParameterHandlerGeneric::GetGlobalSystIndexFromSampleName	(	const std::string &	SampleName,
		const SystType	Type
	)		const

DB Get spline parameters depending on given SampleName.

Definition at line 478 of file ParameterHandlerGeneric.cpp.

                                                                                                                                     {
// ********************************************
  std::vector<int> returnVec;
  for (auto &pair : _fSystToGlobalSystIndexMap[Type]) {
    auto &SystIndex = pair.second;
    if (AppliesToSample(SystIndex, SampleName)) { //If parameter applies to required SampleID
      returnVec.push_back(SystIndex);
    }
  }
  return returnVec;
}

GetNormParameter()

NormParameter ParameterHandlerGeneric::GetNormParameter ( const YAML::Node &  param, const int  Index  ) const

protected

Get Norm params.

Parameters

param	Yaml node describing param
Index	Global parameter index

Definition at line 410 of file ParameterHandlerGeneric.cpp.

                                                                                                    {
// ********************************************
  NormParameter norm;
 
  GetBaseParameter(param, Index, norm);
 
  // ETA size 0 to mean apply to all
  // Ultimately all this information ends up in the NormParams vector
  norm.modes = GetFromManager<std::vector<int>>(param["Mode"], {}, __FILE__ , __LINE__);
  norm.pdgs = GetFromManager<std::vector<int>>(param["NeutrinoFlavour"], {}, __FILE__ , __LINE__);
  norm.preoscpdgs = GetFromManager<std::vector<int>>(param["NeutrinoFlavourUnosc"], {}, __FILE__ , __LINE__);
  norm.targets = GetFromManager<std::vector<int>>(param["TargetNuclei"], {}, __FILE__ , __LINE__);
 
  if(_fLowBound[Index] < 0.) {
    MACH3LOG_ERROR("Normalisation Parameter {} ({}), has lower parameters bound which can go below 0 and is equal {}",
                   GetParFancyName(Index), Index, _fLowBound[Index]);
    MACH3LOG_ERROR("Normalisation parameters can't go bellow 0 as this is unphysical");
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  return norm;
}

GetNormParsFromSampleName()

const std::vector< NormParameter > ParameterHandlerGeneric::GetNormParsFromSampleName

(

const std::string &

SampleName

)

const

DB Get norm/func parameters depending on given SampleName.

Definition at line 583 of file ParameterHandlerGeneric.cpp.

                                                                                                                   {
// ********************************************
  return GetTypeParamsFromSampleName(_fSystToGlobalSystIndexMap[SystType::kNorm], NormParams, SampleName);
}

GetNumParamsFromSampleName()

int ParameterHandlerGeneric::GetNumParamsFromSampleName	(	const std::string &	SampleName,
		const SystType	Type
	)		const

DB Grab the number of parameters for the relevant SampleName.

Parameters

SampleName	property of SampleHandler class based on which we select whether to apply uncertainties or not
Type	Type of syst, for example kNorm, kSpline etc

Definition at line 613 of file ParameterHandlerGeneric.cpp.

                                                                                                              {
// ********************************************
  int returnVal = 0;
  IterateOverParams(SampleName,
    [&](int i) { return GetParamType(i) == Type; }, // Filter condition
    [&](int) { returnVal += 1; } // Action to perform if filter passes
  );
  return returnVal;
}

GetNumParFromGroup()

int ParameterHandlerGeneric::GetNumParFromGroup

(

const std::string &

Group

)

const

KS: Check how many parameters are associated with given group.

Definition at line 1016 of file ParameterHandlerGeneric.cpp.

                                                                            {
// ********************************************
  int Counter = 0;
  for (int i = 0; i < _fNumPar; i++) {
    if(IsParFromGroup(i, Group)) Counter++;
  }
  return Counter;
}

GetOscillationParameters()

OscillationParameter ParameterHandlerGeneric::GetOscillationParameters ( const YAML::Node &  param, const int  Index  ) const

protected

Get Osc params.

Parameters

param	Yaml node describing param
Index	Global parameter index

Definition at line 566 of file ParameterHandlerGeneric.cpp.

                                                                                                                   {
// ********************************************
  OscillationParameter OscParamInfo;
  GetBaseParameter(param, Index, OscParamInfo);
 
  return OscParamInfo;
}

GetOscParsFromSampleName()

std::vector< const M3::float_t * > ParameterHandlerGeneric::GetOscParsFromSampleName

(

const std::string &

SampleName

)

const

Get pointers to Osc params from Sample name.

Definition at line 1027 of file ParameterHandlerGeneric.cpp.

                                                                                                               {
// ********************************************
  std::vector<const M3::float_t*> returnVec;
  for (const auto& pair : _fSystToGlobalSystIndexMap[SystType::kOsc]) {
    const auto& globalIndex = pair.second;
    if (AppliesToSample(globalIndex, SampleName)) {
      returnVec.push_back(RetPointer(globalIndex));
    }
  }
  return returnVec;
}

GetParamType()

SystType ParameterHandlerGeneric::GetParamType ( const int  i ) const

inline

Returns enum describing our param type.

Parameters

i	parameter index

Definition at line 35 of file ParameterHandlerGeneric.h.

{return _fParamType[i];}

GetParamTypeString()

std::string ParameterHandlerGeneric::GetParamTypeString ( const int  i ) const

inline

ETA - just return a string of "spline", "norm" or "functional".

Parameters

i	parameter index

Definition at line 32 of file ParameterHandlerGeneric.h.

{ return SystType_ToString(_fParamType[i]); }

GetParSampleID()

std::vector<std::string> ParameterHandlerGeneric::GetParSampleID ( const int  i ) const

inline

ETA - just return the int of the SampleName, this can be removed to do a string comp at some point.

Parameters

i	parameter index

Definition at line 29 of file ParameterHandlerGeneric.h.

{ return _fSampleNames[i];};

GetParsIndexFromSampleName()

const std::vector< int > ParameterHandlerGeneric::GetParsIndexFromSampleName	(	const std::string &	SampleName,
		const SystType	Type
	)		const

DB Grab the parameter indices for the relevant SampleName.

Parameters

SampleName	property of SampleHandler class based on which we select whether to apply uncertainties or not
Type	Type of syst, for example kNorm, kSpline etc

Definition at line 637 of file ParameterHandlerGeneric.cpp.

                                                                                                                               {
// ********************************************
  std::vector<int> returnVec;
  IterateOverParams(SampleName,
    [&](int i) { return GetParamType(i) == Type; }, // Filter condition
    [&](int i) { returnVec.push_back(i); } // Action to perform if filter passes
  );
  return returnVec;
}

GetParsNamesFromSampleName()

const std::vector< std::string > ParameterHandlerGeneric::GetParsNamesFromSampleName	(	const std::string &	SampleName,
		const SystType	Type
	)		const

DB Grab the parameter names for the relevant SampleName.

Parameters

SampleName	property of SampleHandler class based on which we select whether to apply uncertainties or not
Type	Type of syst, for example kNorm, kSpline etc

Definition at line 625 of file ParameterHandlerGeneric.cpp.

                                                                                                                                     {
// ********************************************
  std::vector<std::string> returnVec;
  IterateOverParams(SampleName,
    [&](int i) { return GetParamType(i) == Type; }, // Filter condition
    [&](int i) { returnVec.push_back(GetParFancyName(i)); } // Action to perform if filter passes
  );
  return returnVec;
}

GetParSplineInterpolation()

SplineInterpolation ParameterHandlerGeneric::GetParSplineInterpolation ( const int  i ) const

inline

Get interpolation type for a given parameter.

Parameters

i	spline parameter index, not confuse with global index

Definition at line 39 of file ParameterHandlerGeneric.h.

{return SplineParams.at(i)._SplineInterpolationType;}

GetParSplineKnotLowerBound()

double ParameterHandlerGeneric::GetParSplineKnotLowerBound ( const int  i ) const

inline

EM: value at which we cap spline knot weight.

Parameters

i	spline parameter index, not confuse with global index

Definition at line 53 of file ParameterHandlerGeneric.h.

{return SplineParams.at(i)._SplineKnotLowBound;}

GetParSplineKnotUpperBound()

double ParameterHandlerGeneric::GetParSplineKnotUpperBound ( const int  i ) const

inline

EM: value at which we cap spline knot weight.

Parameters

i	spline parameter index, not confuse with global index

Definition at line 50 of file ParameterHandlerGeneric.h.

{return SplineParams.at(i)._SplineKnotUpBound;}

GetParSplineName()

std::string ParameterHandlerGeneric::GetParSplineName ( const int  i ) const

inline

Get the name of the spline associated with the spline at index i.

Parameters

i	spline parameter index, not to be confused with global index

Definition at line 44 of file ParameterHandlerGeneric.h.

{return SplineParams.at(i)._fSplineNames;}

GetSplineFileParsNamesFromSampleName()

const std::vector<std::string> ParameterHandlerGeneric::GetSplineFileParsNamesFromSampleName

(

const std::string &

SampleName

)

const

DB Get spline parameters depending on given SampleName.

GetSplineInterpolationFromSampleName()

const std::vector< SplineInterpolation > ParameterHandlerGeneric::GetSplineInterpolationFromSampleName

(

const std::string &

SampleName

)

const

Get the interpolation types for splines affecting a particular SampleName.

Definition at line 377 of file ParameterHandlerGeneric.cpp.

                                                                                                                                    {
// ********************************************
  std::vector<SplineInterpolation> returnVec;
  for (auto &pair : _fSystToGlobalSystIndexMap[SystType::kSpline]) {
    auto &SplineIndex = pair.first;
    auto &SystIndex = pair.second;
 
    if (AppliesToSample(SystIndex, SampleName)) { //If parameter applies to required SampleID
      returnVec.push_back(SplineParams.at(SplineIndex)._SplineInterpolationType);
    }
  }
  return returnVec;
}

GetSplineModeVecFromSampleName()

const std::vector< std::vector< int > > ParameterHandlerGeneric::GetSplineModeVecFromSampleName

(

const std::string &

SampleName

)

const

DB Grab the Spline Modes for the relevant SampleName.

Definition at line 393 of file ParameterHandlerGeneric.cpp.

                                                                                                                           {
// ********************************************
  std::vector< std::vector<int> > returnVec;
  //Need a counter or something to correctly get the index in _fSplineModes since it's not of length nPars
  //Should probably just make a std::map<std::string, int> for param name to FD spline index
  for (auto &pair : _fSystToGlobalSystIndexMap[SystType::kSpline]) {
    auto &SplineIndex = pair.first;
    auto &SystIndex = pair.second;
    if (AppliesToSample(SystIndex, SampleName)) { //If parameter applies to required SampleID
      returnVec.push_back(SplineParams.at(SplineIndex)._fSplineModes);
    }
  }
  return returnVec;
}

GetSplineParameter()

SplineParameter ParameterHandlerGeneric::GetSplineParameter ( const YAML::Node &  param, const int  Index  ) const

protected

Get Spline params.

Parameters

param	Yaml node describing param
Index	Global parameter index

Definition at line 508 of file ParameterHandlerGeneric.cpp.

                                                                                                        {
// ********************************************
  SplineParameter Spline;
 
  GetBaseParameter(param, Index, Spline);
  auto& SplinePar = param["SplineInformation"];
  //Now get the Spline interpolation type
  if (SplinePar["InterpolationType"]) {
    for(int InterpType = 0; InterpType < kSplineInterpolations ; ++InterpType){
      if(SplinePar["InterpolationType"].as<std::string>() == SplineInterpolation_ToString(SplineInterpolation(InterpType)))
        Spline._SplineInterpolationType = SplineInterpolation(InterpType);
    }
  } else { //KS: By default use TSpline3
    Spline._SplineInterpolationType = kTSpline3;
  }
 
  Spline._fSplineNames = Get<std::string>(SplinePar["SplineName"], __FILE__ , __LINE__);
  Spline._SplineKnotUpBound = GetFromManager<double>(SplinePar["SplineKnotUpBound"], M3::DefSplineKnotUpBound, __FILE__ , __LINE__);
  Spline._SplineKnotLowBound = GetFromManager<double>(SplinePar["SplineKnotLowBound"], M3::DefSplineKnotLowBound, __FILE__ , __LINE__);
 
  if(Spline._SplineKnotUpBound != M3::DefSplineKnotUpBound ||  Spline._SplineKnotLowBound != M3::DefSplineKnotLowBound) {
    MACH3LOG_WARN("Spline knot capping enabled with bounds [{}, {}]. For reliable fits, consider modifying the input generation instead.",
                  Spline._SplineKnotLowBound, Spline._SplineKnotUpBound);
  }
  //If there is no mode information given then this will be an empty vector
  Spline._fSplineModes = GetFromManager(SplinePar["Mode"], std::vector<int>(), __FILE__ , __LINE__);
 
  return Spline;
}

GetSplineParsFromSampleName()

const std::vector< SplineParameter > ParameterHandlerGeneric::GetSplineParsFromSampleName

(

const std::string &

SampleName

)

const

KS: Grab the Spline parameters for the relevant SampleName.

Definition at line 590 of file ParameterHandlerGeneric.cpp.

                                                                                                                       {
// ********************************************
  return GetTypeParamsFromSampleName(_fSystToGlobalSystIndexMap[SystType::kSpline], SplineParams, SampleName);
}

GetSplineParsNamesFromSampleName()

const std::vector< std::string > ParameterHandlerGeneric::GetSplineParsNamesFromSampleName

(

const std::string &

SampleName

)

const

DB Get spline parameters depending on given SampleName.

Definition at line 363 of file ParameterHandlerGeneric.cpp.

                                                                                                                      {
// ********************************************
  std::vector<std::string> returnVec;
  for (auto &pair : _fSystToGlobalSystIndexMap[SystType::kSpline]) {
    auto &SplineIndex = pair.first;
    auto &SystIndex = pair.second;
    if (AppliesToSample(SystIndex, SampleName)) { //If parameter applies to required Sample
      returnVec.push_back(SplineParams[SplineIndex]._fSplineNames);
    }
  }
  return returnVec;
}

GetSystIndexFromSampleName()

const std::vector< int > ParameterHandlerGeneric::GetSystIndexFromSampleName	(	const std::string &	SampleName,
		const SystType	Type
	)		const

Grab the index of the syst relative to global numbering.

Parameters

SampleName	property of SampleHandler class based on which we select whether to apply uncertainties or not
Type	Type of syst, for example kNorm, kSpline etc

Definition at line 493 of file ParameterHandlerGeneric.cpp.

                                                                                                                                {
// ********************************************
  std::vector<int> returnVec;
  for (auto &pair : _fSystToGlobalSystIndexMap[Type]) {
    auto &SplineIndex = pair.first;
    auto &systIndex = pair.second;
    if (AppliesToSample(systIndex, SampleName)) { //If parameter applies to required SampleID
      returnVec.push_back(SplineIndex);
    }
  }
  return returnVec;
}

GetTypeParamsFromSampleName()

template<typename ParamT >

std::vector< ParamT > ParameterHandlerGeneric::GetTypeParamsFromSampleName ( const std::map< int, int > &  indexMap, const std::vector< ParamT > &  params, const std::string &  SampleName  ) const

protected

Retrieve parameters that apply to a given sample name.

Template Parameters

ParamT

Type of parameter (e.g., FunctionalParameter, NormParameter).

Parameters

indexMap	Map from local to global parameter indices.
params	Vector of all parameters of the given type.
SampleName	The name of the sample to filter applicable parameters for.

Returns

Vector of parameters of type ParamT that apply to the specified sample.

Definition at line 597 of file ParameterHandlerGeneric.cpp.

                                                                                                                                             {
// ********************************************
  std::vector<ParamT> returnVec;
  for (const auto& pair : indexMap) {
    const auto& localIndex = pair.first;
    const auto& globalIndex = pair.second;
    if (AppliesToSample(globalIndex, SampleName)) {
      returnVec.push_back(params[localIndex]);
    }
  }
  return returnVec;
}

GetUniqueParameterGroups()

std::vector< std::string > ParameterHandlerGeneric::GetUniqueParameterGroups

(

)

const

KS: Get names of all unique parameter groups.

Definition at line 880 of file ParameterHandlerGeneric.cpp.

                                                                             {
// ********************************************
  std::unordered_set<std::string> uniqueGroups;
 
  // Fill the set with unique values
  for (const auto& param : _ParameterGroup) {
    uniqueGroups.insert(param);
  }
 
  // Convert to vector and return
  std::vector<std::string> result(uniqueGroups.begin(), uniqueGroups.end());
  return result;
}

InitialiseFromConfig()

void ParameterHandlerGeneric::InitialiseFromConfig ( const std::vector< std::string > &  YAMLFile )

protected

Initialisation of the class using config.

Parameters

YAMLFile

A vector of strings representing the YAML files used for initialisation of matrix

Definition at line 187 of file ParameterHandlerGeneric.cpp.

                                                                                       {
// ********************************************
  std::map<std::pair<int, int>, std::unique_ptr<TMatrixDSym>> ThrowSubMatrixOverrides;
  LoadAndMergeYAML(YAMLFile, ThrowSubMatrixOverrides);
 
  const int nThreads = M3::GetNThreads();
  //KS: set Random numbers for each thread so each thread has different seed
  //or for one thread if without MULTITHREAD
  random_number.reserve(nThreads);
  for (int iThread = 0; iThread < nThreads; iThread++) {
    random_number.emplace_back(std::make_unique<TRandom3>(0));
  }
  PrintLength = 35;
 
  // Set the covariance matrix
  _fNumPar = int(_fYAMLDoc["Systematics"].size());
 
  ReserveMemory(_fNumPar);
 
  int i = 0;
  std::vector<std::map<std::string,double>> Correlations(_fNumPar);
  std::map<std::string, int> CorrNamesMap;
 
  //ETA - read in the systematics. Would be good to add in some checks to make sure
  //that there are the correct number of entries i.e. are the _fNumPar for Names,
  //PreFitValues etc etc.
  for (auto const &param : _fYAMLDoc["Systematics"])
  {
    _fFancyNames[i] = Get<std::string>(param["Systematic"]["Names"]["FancyName"], __FILE__ , __LINE__);
    _fPreFitValue[i] = Get<double>(param["Systematic"]["ParameterValues"]["PreFitValue"], __FILE__ , __LINE__);
    _fIndivStepScale[i] = Get<double>(param["Systematic"]["StepScale"]["MCMC"], __FILE__ , __LINE__);
    _fError[i] = Get<double>(param["Systematic"]["Error"], __FILE__ , __LINE__);
    if(_fError[i] <= 0) {
      MACH3LOG_ERROR("Error for param {}({}) is negative and equal to {}", _fFancyNames[i], i, _fError[i]);
      throw MaCh3Exception(__FILE__ , __LINE__ );
    }
    //ETA - a bit of a fudge but works
    auto TempBoundsVec = GetBounds(param["Systematic"]["ParameterBounds"]);
    _fLowBound[i] = TempBoundsVec[0];
    _fUpBound[i] = TempBoundsVec[1];
 
    //ETA - now for parameters which are optional and have default values
    _fFlatPrior[i] = GetFromManager<bool>(param["Systematic"]["FlatPrior"], false, __FILE__ , __LINE__);
 
    // Allow to fix param, this setting should be used only for params which are permanently fixed like baseline, please use global config for fixing param more flexibly
    if(GetFromManager<bool>(param["Systematic"]["FixParam"], false, __FILE__ , __LINE__)) {
      SetFixParameter(_fFancyNames[i]);
    }
 
    if(param["Systematic"]["SpecialProposal"]) {
      EnableSpecialProposal(param["Systematic"]["SpecialProposal"], i);
    }
 
    //Fill the map to get the correlations later as well
    CorrNamesMap[param["Systematic"]["Names"]["FancyName"].as<std::string>()]=i;
 
    //Also loop through the correlations
    if(param["Systematic"]["Correlations"]) {
      for(unsigned int Corr_i = 0; Corr_i < param["Systematic"]["Correlations"].size(); ++Corr_i){
        for (YAML::const_iterator it = param["Systematic"]["Correlations"][Corr_i].begin(); it!=param["Systematic"]["Correlations"][Corr_i].end();++it) {
          Correlations[i][it->first.as<std::string>()] = it->second.as<double>();
        }
      }
    }
    i++;
  } // end loop over para
  if(i != _fNumPar) {
    MACH3LOG_CRITICAL("Inconsistent number of params in Yaml  {} vs {}, this indicate wrong syntax", i, i, _fNumPar);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  // load correlation
  LoadCorrelationFromConfig(Correlations, CorrNamesMap);
  if (_fNumPar <= 0) {
    MACH3LOG_ERROR("ParameterHandler object has {} systematics!", _fNumPar);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  for(auto const & matovr : ThrowSubMatrixOverrides){
    SetSubThrowMatrix(matovr.first.first, matovr.first.second, *matovr.second);
  }
 
  Tunes = std::make_unique<ParameterTunes>(_fYAMLDoc["Systematics"]);
 
  MACH3LOG_INFO("Created covariance matrix from files: ");
  for(const auto &file : YAMLFile){
    MACH3LOG_INFO("{} ", file);
  }
  MACH3LOG_INFO("----------------");
  MACH3LOG_INFO("Found {} systematics parameters in total", _fNumPar);
  MACH3LOG_INFO("----------------");
}

InitParameters()

void ParameterHandlerGeneric::InitParameters ( )

protected

Initializes the systematic parameters from the configuration file. This function loads parameters like normalizations and splines from the provided YAML file.

Note

This is used internally during the object's initialization process.

Definition at line 659 of file ParameterHandlerGeneric.cpp.

                                             {
// ********************************************
  for (int i = 0; i < _fNumPar; ++i) {
    //ETA - set the name to be param_% as this is what ProcessorMCMC expects
    _fNames[i] = "param_"+std::to_string(i);
 
    // KS: Plenty of MaCh3 processing script rely on osc params having "fancy name" this is to maintain backward compatibility with them
    if(_fParamType[i] == kOsc) {
      _fNames[i] = _fFancyNames[i];
 
      if(_ParameterGroup[i] != "Osc"){
        MACH3LOG_ERROR("Parameter {}, is of type Oscillation but doesn't belong to Osc group", _fFancyNames[i]);
        MACH3LOG_ERROR("It belongs to {} group", _ParameterGroup[i]);
        throw MaCh3Exception(__FILE__ , __LINE__ );
      }
    }
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wuseless-cast"
    // Set ParameterHandler parameters (Curr = current, Prop = proposed, Sigma = step)
    _fCurrVal[i] = _fPreFitValue[i];
    _fPropVal[i] = static_cast<M3::float_t>(_fCurrVal[i]);
    #pragma GCC diagnostic pop
  }
  Randomize();
  //KS: Transfer the starting parameters to the PCA basis, you don't want to start with zero..
  if (pca) {
    PCAObj->SetInitialParameters();
  }
}

InitParametersTypeFromConfig()

void ParameterHandlerGeneric::InitParametersTypeFromConfig ( )

protected

Parses the YAML configuration to set up cross-section parameters. The YAML file defines the types of systematic errors, interpolation types, and bounds for splines.

Definition at line 281 of file ParameterHandlerGeneric.cpp.

                                                           {
// ********************************************
  _fSystToGlobalSystIndexMap.resize(SystType::kSystTypes);
 
  _fParamType = std::vector<SystType>(_fNumPar);
  _ParameterGroup = std::vector<std::string>(_fNumPar);
  _fSampleNames = std::vector<std::vector<std::string>>(_fNumPar);
 
  //KS: We know at most how params we expect so reserve memory for max possible params. Later we will shrink to size to not waste memory. Reserving means slightly faster loading and possible less memory fragmentation.
  NormParams.reserve(_fNumPar);
  SplineParams.reserve(_fNumPar);
  FuncParams.reserve(_fNumPar);
  OscParams.reserve(_fNumPar);
 
  int i = 0;
  unsigned int ParamCounter[SystType::kSystTypes] = {0};
  //ETA - read in the systematics. Would be good to add in some checks to make sure
  //that there are the correct number of entries i.e. are the _fNumPars for Names,
  //PreFitValues etc etc.
  for (auto const &param : _fYAMLDoc["Systematics"])
  {
    _ParameterGroup[i] = Get<std::string>(param["Systematic"]["ParameterGroup"], __FILE__ , __LINE__);
    _fSampleNames[i] = GetFromManager<std::vector<std::string>>(param["Systematic"]["SampleNames"], {}, __FILE__, __LINE__);
 
    //Fill the map to get the correlations later as well
    auto ParamType = Get<std::string>(param["Systematic"]["Type"], __FILE__ , __LINE__);
    //Now load in variables for spline systematics only
    if (ParamType == SystType_ToString(SystType::kSpline))
    {
      //Set param type
      _fParamType[i] = SystType::kSpline;
      // Fill Spline info
      SplineParams.push_back(GetSplineParameter(param["Systematic"], i));
 
      //Insert the mapping from the spline index i.e. the length of _fSplineNames etc
      //to the Systematic index i.e. the counter for things like _fSampleID
      _fSystToGlobalSystIndexMap[SystType::kSpline].insert(std::make_pair(ParamCounter[SystType::kSpline], i));
      ParamCounter[SystType::kSpline]++;
    } else if(ParamType == SystType_ToString(SystType::kNorm)) {
      _fParamType[i] = SystType::kNorm;
      NormParams.push_back(GetNormParameter(param["Systematic"], i));
      _fSystToGlobalSystIndexMap[SystType::kNorm].insert(std::make_pair(ParamCounter[SystType::kNorm], i));
      ParamCounter[SystType::kNorm]++;
    } else if(ParamType == SystType_ToString(SystType::kFunc)){
      _fParamType[i] = SystType::kFunc;
      FuncParams.push_back(GetFunctionalParameters(param["Systematic"], i));
      _fSystToGlobalSystIndexMap[SystType::kFunc].insert(std::make_pair(ParamCounter[SystType::kFunc], i));
      ParamCounter[SystType::kFunc]++;
    } else if(ParamType == SystType_ToString(SystType::kOsc)){
      _fParamType[i] = SystType::kOsc;
      OscParams.push_back(GetOscillationParameters(param["Systematic"], i));
      _fSystToGlobalSystIndexMap[SystType::kOsc].insert(std::make_pair(ParamCounter[SystType::kOsc], i));
      ParamCounter[SystType::kOsc]++;
    } else{
      MACH3LOG_ERROR("Given unrecognised systematic type: {}", ParamType);
      std::string expectedTypes = "Expecting ";
      for (int s = 0; s < SystType::kSystTypes; ++s) {
        if (s > 0) expectedTypes += ", ";
        expectedTypes += SystType_ToString(static_cast<SystType>(s)) + "\"";
      }
      expectedTypes += ".";
      MACH3LOG_ERROR(expectedTypes);
      throw MaCh3Exception(__FILE__, __LINE__);
    }
    i++;
  } //end loop over params
 
  //KS We resized them above to all params to fight memory fragmentation, now let's resize to fit only allocated memory to save RAM
  NormParams.shrink_to_fit();
  SplineParams.shrink_to_fit();
  FuncParams.shrink_to_fit();
  OscParams.shrink_to_fit();
}

IsParFromGroup()

bool ParameterHandlerGeneric::IsParFromGroup	(	const int	i,
		const std::string &	Group
	)		const

Checks if parameter belongs to a given group.

Parameters

i	parameter index
Group	name of group, like Xsec or Flux

Returns

bool telling whether param is part of group

Definition at line 1003 of file ParameterHandlerGeneric.cpp.

                                                                                      {
// ********************************************
  std::string groupLower = Group;
  std::string paramGroupLower = _ParameterGroup[i];
 
  // KS: Convert both strings to lowercase, this way comparison will be case insensitive
  std::transform(groupLower.begin(), groupLower.end(), groupLower.begin(), ::tolower);
  std::transform(paramGroupLower.begin(), paramGroupLower.end(), paramGroupLower.begin(), ::tolower);
 
  return groupLower == paramGroupLower;
}

IterateOverParams()

template<typename FilterFunc , typename ActionFunc >

void ParameterHandlerGeneric::IterateOverParams ( const std::string &  SampleName, FilterFunc  filter, ActionFunc  action  ) const

protected

Iterates over parameters and applies a filter and action function.

This template function provides a way to iterate over parameters associated with a specific Sample ID (SampleName). It applies a filter function to determine which parameters to process and an action function to define what to do with the selected parameters.

Template Parameters

FilterFunc	The type of the filter function used to determine which parameters to include.
ActionFunc	The type of the action function applied to each selected parameter.

Parameters

SampleName

The Sample ID used to filter parameters.

Definition at line 649 of file ParameterHandlerGeneric.cpp.

                                                                                                                       {
// ********************************************
  for (int i = 0; i < _fNumPar; ++i) {
    if ((AppliesToSample(i, SampleName)) && filter(i)) { // Common filter logic
      action(i); // Specific action for each function
    }
  }
}

LoadAndMergeYAML()

void ParameterHandlerGeneric::LoadAndMergeYAML ( const std::vector< std::string > &  YAMLFile, std::map< std::pair< int, int >, std::unique_ptr< TMatrixDSym >> &  overrides  )

protected

Initialise single yaml based on several yaml files.

Definition at line 52 of file ParameterHandlerGeneric.cpp.

                                                                                                                              {
// ********************************************
  int running_num_file_pars = 0;
 
  _fYAMLDoc["Systematics"] = YAML::Node(YAML::NodeType::Sequence);
  for(unsigned int i = 0; i < YAMLFile.size(); i++)
  {
    YAML::Node YAMLDocTemp = M3OpenConfig(YAMLFile[i]);
 
    if (YAMLDocTemp["ThrowMatrixOverride"]) { // LP: this allows us to put in
      // proposal matrix overrides per
      // parameter-containing file, add
      // the block diagonal proposal
      // matrix to a list and overwrite
      // the throw matrix after set up.
      auto filename =
      YAMLDocTemp["ThrowMatrixOverride"]["file"].as<std::string>();
      TFile *submatrix_file = TFile::Open(filename.c_str());
 
      auto matrixname =
      YAMLDocTemp["ThrowMatrixOverride"]["matrix"].as<std::string>();
      std::unique_ptr<TMatrixDSym> submatrix{
        submatrix_file->Get<TMatrixDSym>(matrixname.c_str())};
        if (!submatrix) {
          MACH3LOG_CRITICAL("Covariance matrix {} doesn't exist in file: {}",
                            matrixname, filename);
          throw MaCh3Exception(__FILE__, __LINE__);
        }
        auto numrows = submatrix->GetNrows();
        // LP: the -1 here is because we specify the last index for consistency
        // with PCAHandler, not the first index after the end as is more common
        // throughout computer science...
        ThrowSubMatrixOverrides[{running_num_file_pars,
          running_num_file_pars + (numrows - 1)}] = std::move(submatrix);
 
          // LP: check names by default, but have option to disable check if you
          // know what you're doing
          if (!bool(YAMLDocTemp["ThrowMatrixOverride"]["check_names"]) ||
            YAMLDocTemp["ThrowMatrixOverride"]["check_names"].as<bool>()) {
            auto nametree = submatrix_file->Get<TTree>("param_names");
          if (!nametree) {
            MACH3LOG_CRITICAL("TTree param_names doesn't exist in file: {}. Set "
            "ThrowMatrixOverride: {{ check_names: False }} to "
            "disable this check.",
            filename);
            throw MaCh3Exception(__FILE__, __LINE__);
          }
          std::string *param_name = nullptr;
          nametree->SetBranchAddress("name", &param_name);
 
          if (nametree->GetEntries() != int(YAMLDocTemp["Systematics"].size())) {
            MACH3LOG_CRITICAL("TTree param_names in file: {} has {} entries, but "
            "the corresponding yaml file only declares {} "
            "parameters. Set ThrowMatrixOverride: {{ "
              "check_names: False }} to disable this check.",
              filename, nametree->GetEntries(),
                              YAMLDocTemp["Systematics"].size());
            throw MaCh3Exception(__FILE__, __LINE__);
          }
 
          int pit = 0;
          for (const auto &param : YAMLDocTemp["Systematics"]) {
            nametree->GetEntry(pit++);
            auto yaml_pname = Get<std::string>(
              param["Systematic"]["Names"]["FancyName"], __FILE__, __LINE__);
            if ((*param_name) != yaml_pname) {
              MACH3LOG_CRITICAL(
                "TTree param_names in file: {} at entry {} has parameter {}, "
                "but "
                "the corresponding yaml parameter is named {}. Set "
                "ThrowMatrixOverride: {{ "
                  "check_names: False }} to disable this check.",
                  filename, pit, (*param_name), yaml_pname);
              throw MaCh3Exception(__FILE__, __LINE__);
            }
          }
            }
            submatrix_file->Close();
    }
 
    for (const auto& item : YAMLDocTemp["Systematics"]) {
      _fYAMLDoc["Systematics"].push_back(item);
      running_num_file_pars++;
    }
  }
}

LoadCorrelationFromConfig()

void ParameterHandlerGeneric::LoadCorrelationFromConfig ( std::vector< std::map< std::string, double >> &  Correlations, std::map< std::string, int > &  CorrNamesMap  )

protected

Load correlation from yaml config.

Definition at line 141 of file ParameterHandlerGeneric.cpp.

                                                                                              {
// ********************************************
  // ETA Now that we've been through all systematic let's fill the covmatrix
  //This makes the root TCov from YAML
  TMatrixDSym* _fCovMatrix = new TMatrixDSym(_fNumPar);
  for(int j = 0; j < _fNumPar; j++) {
    (*_fCovMatrix)(j, j) = _fError[j]*_fError[j];
    //Get the map of parameter name to correlation from the Correlations object
    for (auto const& pair : Correlations[j]) {
      auto const& key = pair.first;
      auto const& val = pair.second;
      int index = -1;
      //If you found the parameter name then get the index
      if (CorrNamesMap.find(key) != CorrNamesMap.end()) {
        index = CorrNamesMap[key];
      } else {
        MACH3LOG_ERROR("Parameter {} not in list! Check your spelling?", key);
        throw MaCh3Exception(__FILE__ , __LINE__ );
      }
      double Corr1 = val;
      double Corr2 = 0;
      if(Correlations[index].find(_fFancyNames[j]) != Correlations[index].end()) {
        Corr2 = Correlations[index][_fFancyNames[j]];
        //Do they agree to better than float precision?
        if(std::abs(Corr2 - Corr1) > FLT_EPSILON) {
          MACH3LOG_ERROR("Correlations are not equal between {} and {}", _fFancyNames[j], key);
          MACH3LOG_ERROR("Got : {} and {}", Corr2, Corr1);
          throw MaCh3Exception(__FILE__ , __LINE__ );
        }
      } else {
        MACH3LOG_ERROR("Correlation does not appear reciprocally between {} and {}", _fFancyNames[j], key);
        throw MaCh3Exception(__FILE__ , __LINE__ );
      }
      (*_fCovMatrix)(j, index)= (*_fCovMatrix)(index, j) = Corr1*_fError[j]*_fError[index];
    }
  }
 
  //Now make positive definite
  MakePosDef(_fCovMatrix);
  SetCovMatrix(_fCovMatrix);
}

Print()

void ParameterHandlerGeneric::Print ( ) const

protected

Print information about the whole object once it is set.

Definition at line 691 of file ParameterHandlerGeneric.cpp.

                                          {
// ********************************************
  MACH3LOG_INFO("#################################################");
  MACH3LOG_INFO("Printing ParameterHandlerGeneric:");
 
  PrintGlobablInfo();
 
  PrintNormParams();
 
  PrintSplineParams();
 
  PrintFunctionalParams();
 
  PrintOscillationParams();
 
  PrintParameterGroups();
 
  MACH3LOG_INFO("Finished");
  MACH3LOG_INFO("#################################################");
 
  CheckCorrectInitialisation();
} // End

PrintFunctionalParams()

void ParameterHandlerGeneric::PrintFunctionalParams ( ) const

protected

Prints functional parameters.

Definition at line 830 of file ParameterHandlerGeneric.cpp.

                                                          {
// ********************************************
  MACH3LOG_INFO("Functional parameters: {}", _fSystToGlobalSystIndexMap[SystType::kFunc].size());
  if(_fSystToGlobalSystIndexMap[SystType::kFunc].size() == 0) return;
  MACH3LOG_INFO("┌────┬──────────┬────────────────────────────────────────┐");
  MACH3LOG_INFO("│{0:4}│{1:10}│{2:40}│", "#", "Global #", "Name");
  MACH3LOG_INFO("├────┼──────────┼────────────────────────────────────────┤");
  for (auto &pair : _fSystToGlobalSystIndexMap[SystType::kFunc]) {
    auto &FuncIndex = pair.first;
    auto &GlobalIndex = pair.second;
    MACH3LOG_INFO("│{0:4}│{1:<10}│{2:40}│", std::to_string(FuncIndex), GlobalIndex, GetParFancyName(GlobalIndex));
  }
  MACH3LOG_INFO("└────┴──────────┴────────────────────────────────────────┘");
}

PrintGlobablInfo()

void ParameterHandlerGeneric::PrintGlobablInfo ( ) const

protected

Prints general information about the ParameterHandler object.

Definition at line 715 of file ParameterHandlerGeneric.cpp.

                                                     {
// ********************************************
  MACH3LOG_INFO("============================================================================================================================================================");
  MACH3LOG_INFO("{:<5} {:2} {:<40} {:2} {:<10} {:2} {:<10} {:2} {:<10} {:2} {:<10} {:2} {:<10} {:2} {:<20} {:2} {:<10}", "#", "|", "Name", "|", "Prior", "|", "Error", "|", "Lower", "|", "Upper", "|", "StepScale", "|", "SampleNames", "|", "Type");
  MACH3LOG_INFO("------------------------------------------------------------------------------------------------------------------------------------------------------------");
  for (int i = 0; i < GetNumParams(); i++) {
    std::string ErrString = fmt::format("{:.2f}", _fError[i]);
    std::string SampleNameString = "";
    for (const auto& SampleName : _fSampleNames[i]) {
      if (!SampleNameString.empty()) {
        SampleNameString += ", ";
      }
      SampleNameString += SampleName;
    }
    MACH3LOG_INFO("{:<5} {:2} {:<40} {:2} {:<10} {:2} {:<10} {:2} {:<10} {:2} {:<10} {:2} {:<10} {:2} {:<20} {:2} {:<10}", i, "|", GetParFancyName(i), "|", _fPreFitValue[i], "|", "+/- " + ErrString, "|", _fLowBound[i], "|", _fUpBound[i], "|", _fIndivStepScale[i], "|", SampleNameString, "|", SystType_ToString(_fParamType[i]));
  }
  MACH3LOG_INFO("============================================================================================================================================================");
}

PrintNormParams()

void ParameterHandlerGeneric::PrintNormParams ( ) const

protected

Prints normalization parameters.

Definition at line 735 of file ParameterHandlerGeneric.cpp.

                                                    {
// ********************************************
  // Output the normalisation parameters as a sanity check!
  MACH3LOG_INFO("Normalisation parameters:  {}", NormParams.size());
  if(_fSystToGlobalSystIndexMap[SystType::kNorm].size() == 0) return;
 
  bool have_parameter_with_kin_bounds = false;
 
  //KS: Consider making some class producing table..
  MACH3LOG_INFO("┌────┬──────────┬────────────────────────────────────────┬────────────────────┬────────────────────┬────────────────────┐");
  MACH3LOG_INFO("│{0:4}│{1:10}│{2:40}│{3:20}│{4:20}│{5:20}│", "#", "Global #", "Name", "Int. mode", "Target", "pdg");
  MACH3LOG_INFO("├────┼──────────┼────────────────────────────────────────┼────────────────────┼────────────────────┼────────────────────┤");
 
  for (unsigned int i = 0; i < NormParams.size(); ++i)
  {
    std::string intModeString;
    for (unsigned int j = 0; j < NormParams[i].modes.size(); j++) {
      intModeString += std::to_string(NormParams[i].modes[j]);
      intModeString += " ";
    }
    if (NormParams[i].modes.empty()) intModeString += "all";
 
    std::string targetString;
    for (unsigned int j = 0; j < NormParams[i].targets.size(); j++) {
      targetString += std::to_string(NormParams[i].targets[j]);
      targetString += " ";
    }
    if (NormParams[i].targets.empty()) targetString += "all";
 
    std::string pdgString;
    for (unsigned int j = 0; j < NormParams[i].pdgs.size(); j++) {
      pdgString += std::to_string(NormParams[i].pdgs[j]);
      pdgString += " ";
    }
    if (NormParams[i].pdgs.empty()) pdgString += "all";
 
    MACH3LOG_INFO("│{: <4}│{: <10}│{: <40}│{: <20}│{: <20}│{: <20}│", i, NormParams[i].index, NormParams[i].name, intModeString, targetString, pdgString);
 
    if(NormParams[i].hasKinBounds) have_parameter_with_kin_bounds = true;
  }
  MACH3LOG_INFO("└────┴──────────┴────────────────────────────────────────┴────────────────────┴────────────────────┴────────────────────┘");
 
  if(have_parameter_with_kin_bounds) {
    MACH3LOG_INFO("Normalisation parameters KinematicCuts information");
    MACH3LOG_INFO("┌────┬──────────┬────────────────────────────────────────┬────────────────────┬────────────────────────────────────────┐");
    MACH3LOG_INFO("│{0:4}│{1:10}│{2:40}│{3:20}│{4:40}│", "#", "Global #", "Name", "KinematicCut", "Value");
    MACH3LOG_INFO("├────┼──────────┼────────────────────────────────────────┼────────────────────┼────────────────────────────────────────┤");
    for (unsigned int i = 0; i < NormParams.size(); ++i)
    {
      //skip parameters with no KinematicCuts
      if(!NormParams[i].hasKinBounds) continue;
 
      const long unsigned int ncuts = NormParams[i].KinematicVarStr.size();
      for(long unsigned int icut = 0; icut < ncuts; icut++) {
        std::string kinematicCutValueString;
        for(const auto & value : NormParams[i].Selection[icut]) {
          for (const auto& v : value) {
            kinematicCutValueString += fmt::format("{:.2f} ", v);
          }
        }
        if(icut == 0)
          MACH3LOG_INFO("│{: <4}│{: <10}│{: <40}│{: <20}│{: <40}│", i, NormParams[i].index, NormParams[i].name, NormParams[i].KinematicVarStr[icut], kinematicCutValueString);
        else
          MACH3LOG_INFO("│{: <4}│{: <10}│{: <40}│{: <20}│{: <40}│", "", "", "", NormParams[i].KinematicVarStr[icut], kinematicCutValueString);
      }//icut
    }//i
    MACH3LOG_INFO("└────┴──────────┴────────────────────────────────────────┴────────────────────┴────────────────────────────────────────┘");
  }
  else
    MACH3LOG_INFO("No normalisation parameters have KinematicCuts defined");
}

PrintOscillationParams()

void ParameterHandlerGeneric::PrintOscillationParams ( ) const

protected

Prints oscillation parameters.

Definition at line 846 of file ParameterHandlerGeneric.cpp.

                                                           {
// ********************************************
  MACH3LOG_INFO("Oscillation parameters: {}", _fSystToGlobalSystIndexMap[SystType::kOsc].size());
  if(_fSystToGlobalSystIndexMap[SystType::kOsc].size() == 0) return;
  MACH3LOG_INFO("┌────┬──────────┬────────────────────────────────────────┐");
  MACH3LOG_INFO("│{0:4}│{1:10}│{2:40}│", "#", "Global #", "Name");
  MACH3LOG_INFO("├────┼──────────┼────────────────────────────────────────┤");
  for (auto &pair : _fSystToGlobalSystIndexMap[SystType::kOsc]) {
    auto &OscIndex = pair.first;
    auto &GlobalIndex = pair.second;
    MACH3LOG_INFO("│{0:4}│{1:<10}│{2:40}│", std::to_string(OscIndex), GlobalIndex, GetParFancyName(GlobalIndex));
  }
  MACH3LOG_INFO("└────┴──────────┴────────────────────────────────────────┘");
}

PrintParameterGroups()

void ParameterHandlerGeneric::PrintParameterGroups ( ) const

protected

Prints groups of parameters.

Definition at line 862 of file ParameterHandlerGeneric.cpp.

                                                         {
// ********************************************
  // KS: Create a map to store the counts of unique strings, in principle this could be in header file
  std::unordered_map<std::string, int> paramCounts;
 
  std::for_each(_ParameterGroup.begin(), _ParameterGroup.end(),
                [&paramCounts](const std::string& param) {
                  paramCounts[param]++;
                });
 
  MACH3LOG_INFO("Printing parameter groups");
  // Output the counts
  for (const auto& pair : paramCounts) {
    MACH3LOG_INFO("Found {}: {} params", pair.second, pair.first);
  }
}

PrintSplineParams()

void ParameterHandlerGeneric::PrintSplineParams ( ) const

protected

Prints spline parameters.

Definition at line 808 of file ParameterHandlerGeneric.cpp.

                                                      {
// ********************************************
  MACH3LOG_INFO("Spline parameters: {}", _fSystToGlobalSystIndexMap[SystType::kSpline].size());
  if(_fSystToGlobalSystIndexMap[SystType::kSpline].size() == 0) return;
  MACH3LOG_INFO("=====================================================================================================================================================================");
  MACH3LOG_INFO("{:<4} {:<2} {:<40} {:<2} {:<40} {:<2} {:<20} {:<2} {:<20} {:<2} {:<20} {:<2}", "#", "|", "Name", "|", "Spline Name", "|", "Spline Interpolation", "|", "Low Knot Bound", "|", "Up Knot Bound", "|");
  MACH3LOG_INFO("---------------------------------------------------------------------------------------------------------------------------------------------------------------------");
  for (auto &pair : _fSystToGlobalSystIndexMap[SystType::kSpline]) {
    auto &SplineIndex = pair.first;
    auto &GlobalIndex = pair.second;
 
    MACH3LOG_INFO("{:<4} {:<2} {:<40} {:<2} {:<40} {:<2} {:<20} {:<2} {:<20} {:<2} {:<20} {:<2}",
                  SplineIndex, "|", GetParFancyName(GlobalIndex), "|",
                  SplineParams[SplineIndex]._fSplineNames, "|",
                  SplineInterpolation_ToString(GetParSplineInterpolation(SplineIndex)), "|",
                  GetParSplineKnotLowerBound(SplineIndex), "|",
                  GetParSplineKnotUpperBound(SplineIndex), "|");
  }
  MACH3LOG_INFO("=====================================================================================================================================================================");
}

SetFixGroupOnlyParameters() [1/2]

void ParameterHandlerGeneric::SetFixGroupOnlyParameters

(

const std::string &

Group

)

TN Method to set parameters within a group to be fixed to their prior values.

Parameters

Group

name of the parameter group (Xsec, Flux, Osc, etc.)

Definition at line 971 of file ParameterHandlerGeneric.cpp.

                                                                              {
// ********************************************
  for (int i = 0; i < _fNumPar; ++i)
    if(IsParFromGroup(i, Group)) SetFixParameter(i);
}

SetFixGroupOnlyParameters() [2/2]

void ParameterHandlerGeneric::SetFixGroupOnlyParameters

(

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

Groups

)

TN Method to set parameters of certain groups to be fixed to their prior values.

Parameters

Groups

vector of group names (e.g. {"Xsec", "Flux"})

Definition at line 979 of file ParameterHandlerGeneric.cpp.

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

SetFreeGroupOnlyParameters() [1/2]

void ParameterHandlerGeneric::SetFreeGroupOnlyParameters

(

const std::string &

Group

)

TN Method to set parameters within a group to be treated as free.

Parameters

Group

name of the parameter group (Xsec, Flux, Osc, etc.)

Definition at line 987 of file ParameterHandlerGeneric.cpp.

                                                                               {
// ********************************************
  for (int i = 0; i < _fNumPar; ++i)
    if(IsParFromGroup(i, Group)) SetFreeParameter(i);
}

SetFreeGroupOnlyParameters() [2/2]

void ParameterHandlerGeneric::SetFreeGroupOnlyParameters

(

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

Groups

)

TN Method to set parameters of certain groups to be treated as free.

Parameters

Groups

vector of group names (e.g. {"Xsec", "Flux"})

Definition at line 995 of file ParameterHandlerGeneric.cpp.

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

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 mimics functionality of SetParameters

Definition at line 937 of file ParameterHandlerGeneric.cpp.

                                                                                                          {
// ********************************************
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wuseless-cast"
  // If empty, set the proposed to prior
  if (Pars.empty()) {
    for (int i = 0; i < _fNumPar; i++) {
      if(IsParFromGroup(i, Group)) _fPropVal[i] = static_cast<M3::float_t>(_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] = static_cast<M3::float_t>(Pars[Counter]);
        Counter++;
      }
    }
  }
  // And if pca make the transfer
  if (pca) {
    PCAObj->TransferToPCA();
    PCAObj->TransferToParam();
  }
  #pragma GCC diagnostic pop
}

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

Groups

vector of group names, like Xsec or Flux

Definition at line 928 of file ParameterHandlerGeneric.cpp.

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

Member Data Documentation

_fParamType

std::vector<SystType> ParameterHandlerGeneric::_fParamType

protected

Type of parameter like norm, spline etc.

Definition at line 221 of file ParameterHandlerGeneric.h.

_fSampleNames

std::vector<std::vector<std::string> > ParameterHandlerGeneric::_fSampleNames

protected

Tells to which samples object param should be applied.

Definition at line 218 of file ParameterHandlerGeneric.h.

_fSystToGlobalSystIndexMap

std::vector<std::map<int, int> > ParameterHandlerGeneric::_fSystToGlobalSystIndexMap

protected

Map between number of given parameter type with global parameter numbering. For example 2nd norm param may be 10-th global param.

Definition at line 227 of file ParameterHandlerGeneric.h.

_ParameterGroup

std::vector<std::string> ParameterHandlerGeneric::_ParameterGroup

protected

KS: Allow to group parameters for example to affect only cross-section or only flux etc.

Definition at line 224 of file ParameterHandlerGeneric.h.

FuncParams

std::vector<FunctionalParameter> ParameterHandlerGeneric::FuncParams

protected

Vector containing info for functional systematics.

Definition at line 236 of file ParameterHandlerGeneric.h.

NormParams

std::vector<NormParameter> ParameterHandlerGeneric::NormParams

protected

Vector containing info for normalisation systematics.

Definition at line 233 of file ParameterHandlerGeneric.h.

OscParams

std::vector<OscillationParameter> ParameterHandlerGeneric::OscParams

protected

Vector containing info for functional systematics.

Definition at line 239 of file ParameterHandlerGeneric.h.

SplineParams

std::vector<SplineParameter> ParameterHandlerGeneric::SplineParams

protected

Vector containing info for normalisation systematics.

Definition at line 230 of file ParameterHandlerGeneric.h.

---

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

• Parameters/ParameterHandlerGeneric.h
• Parameters/ParameterHandlerGeneric.cpp