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:

[legend]

Collaboration diagram for ParameterHandlerGeneric:

[legend]

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.

	~ParameterHandlerGeneric ()
	Destructor.

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.

std::string	GetParamTypeString (const int i) const
	ETA - just return a string of "spline", "norm" or "functional".

SystType	GetParamType (const int i) const
	Returns enum describing our param type.

SplineInterpolation	GetParSplineInterpolation (const int i) const
	Get interpolation type for a given parameter.

const std::vector< SplineInterpolation >	GetSplineInterpolationFromSampleName (const std::string &SampleName)
	Get the interpolation types for splines affecting a particular SampleName.

std::string	GetParSplineName (const int i) const
	Get the name of the spline associated with the spline at index i.

const std::vector< int >	GetGlobalSystIndexFromSampleName (const std::string &SampleName, const SystType Type)
	DB Get spline parameters depending on given SampleName.

double	GetParSplineKnotUpperBound (const int i) const
	EM: value at which we cap spline knot weight.

double	GetParSplineKnotLowerBound (const int i) const
	EM: value at which we cap spline knot weight.

int	GetNumParamsFromSampleName (const std::string &SampleName, const SystType Type)
	DB Grab the number of parameters for the relevant SampleName.

const std::vector< std::string >	GetParsNamesFromSampleName (const std::string &SampleName, const SystType Type)
	DB Grab the parameter names for the relevant SampleName.

const std::vector< int >	GetParsIndexFromSampleName (const std::string &SampleName, const SystType Type)
	DB Grab the parameter indices for the relevant SampleName.

const std::vector< std::string >	GetSplineParsNamesFromSampleName (const std::string &SampleName)
	DB Get spline parameters depending on given SampleName.

const std::vector< std::string >	GetSplineFileParsNamesFromSampleName (const std::string &SampleName)
	DB Get spline parameters depending on given SampleName.

const std::vector< std::vector< int > >	GetSplineModeVecFromSampleName (const std::string &SampleName)
	DB Grab the Spline Modes for the relevant SampleName.

const std::vector< int >	GetSystIndexFromSampleName (const std::string &SampleName, const SystType Type) const
	Grab the index of the syst relative to global numbering.

const std::vector< NormParameter >	GetNormParsFromSampleName (const std::string &SampleName) const
	DB Get norm/func parameters depending on given SampleName.

const std::vector< FunctionalParameter >	GetFunctionalParametersFromSampleName (const std::string &SampleName) const
	HH Get functional parameters for the relevant SampleName.

const std::vector< SplineParameter >	GetSplineParsFromSampleName (const std::string &SampleName) const
	KS: Grab the Spline parameters for the relevant SampleName.

bool	IsParFromGroup (const int i, const std::string &Group) const
	Checks if parameter belongs to a given group.

int	GetNumParFromGroup (const std::string &Group) const
	KS: Check how many parameters are associated with given group.

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.

void	SetGroupOnlyParameters (const std::vector< std::string > &Groups)
	KS Function to set to prior parameters of a given groups or values from vector.

void	DumpMatrixToFile (const std::string &Name)
	Dump Matrix to ROOT file, useful when we need to pass matrix info to another fitting group.

std::vector< const double * >	GetOscParsFromSampleName (const std::string &SampleName)
	Get pointers to Osc params from Sample name.

Public Member Functions inherited from ParameterHandlerBase
	ParameterHandlerBase (const std::vector< std::string > &YAMLFile, std::string name, double threshold=-1, int FirstPCAdpar=-999, int LastPCAdpar=-999)
	ETA - constructor for a YAML file.

	ParameterHandlerBase (std::string name, std::string file, double threshold=-1, int FirstPCAdpar=-999, int LastPCAdpar=-999)
	"Usual" constructors from root file

virtual	~ParameterHandlerBase ()
	Destructor.

void	SetCovMatrix (TMatrixDSym *cov)
	Set covariance matrix.

void	SetName (const std::string &name)
	Set matrix name.

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

void	SetSingleParameter (const int parNo, const double parVal)
	Set value of single param to a given value.

void	SetPar (const int i, const double val)
	Set all the covariance matrix parameters to a user-defined value.

void	SetParCurrProp (const int i, const double val)
	Set current parameter value.

void	SetParProp (const int i, const double val)
	Set proposed parameter value.

void	SetParameters (const std::vector< double > &pars={})
	Set parameter values using vector, it has to have same size as covariance class.

void	SetFlatPrior (const int i, const bool eL)
	Set if parameter should have flat prior or not.

void	SetRandomThrow (const int i, const double rand)
	Set random value useful for debugging/CI.

double	GetRandomThrow (const int i) const
	Get random value useful for debugging/CI.

void	SetBranches (TTree &tree, const bool SaveProposal=false)
	set branches for output file

void	SetStepScale (const double scale)
	Set global step scale for covariance object.

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)

void	SetIndivStepScale (const std::vector< double > &stepscale)
	DB Function to set fIndivStepScale from a vector (Can be used from execs and inside covariance constructors)

void	SetPrintLength (const unsigned int PriLen)
	KS: In case someone really want to change this.

void	SaveUpdatedMatrixConfig ()
	KS: After step scale, prefit etc. value were modified save this modified config.

void	ThrowParProp (const double mag=1.)
	Throw the proposed parameter by mag sigma. Should really just have the user specify this throw by having argument double.

void	ThrowParCurr (const double mag=1.)
	Helper function to throw the current parameter by mag sigma. Can study bias in MCMC with this; put different starting parameters.

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

void	RandomConfiguration ()
	Randomly throw the parameters in their 1 sigma range.

int	CheckBounds () const _noexcept_
	Check if parameters were proposed outside physical boundary.

double	CalcLikelihood () const _noexcept_
	Calc penalty term based on inverted covariance matrix.

virtual double	GetLikelihood ()
	Return CalcLikelihood if some params were thrown out of boundary return LARGE_LOGL

TMatrixDSym *	GetCovMatrix () const
	Return covariance matrix.

TMatrixDSym *	GetInvCovMatrix () const
	Return inverted covariance matrix.

double	GetInvCovMatrix (const int i, const int j) const
	Return inverted covariance matrix.

double	GetCorrThrows (const int i) const
	Return correlated throws.

bool	GetFlatPrior (const int i) const
	Get if param has flat prior or not.

std::string	GetName () const
	Get name of covariance.

std::string	GetParName (const int i) const
	Get name of parameter.

int	GetParIndex (const std::string &name) const
	Get index based on name.

std::string	GetParFancyName (const int i) const
	Get fancy name of the Parameter.

std::string	GetInputFile () const
	Get name of input file.

double	GetDiagonalError (const int i) const
	Get diagonal error for ith parameter.

double	GetError (const int i) const
	Get the error for the ith parameter.

void	ResetIndivStepScale ()
	Adaptive Step Tuning Stuff.

void	InitialiseAdaption (const YAML::Node &adapt_manager)
	Initialise adaptive MCMC.

void	SaveAdaptiveToFile (const std::string &outFileName, const std::string &systematicName)
	Save adaptive throw matrix to file.

bool	GetDoAdaption () const
	Do we adapt or not.

void	SetThrowMatrix (TMatrixDSym *cov)
	Use new throw matrix, used in adaptive MCMC.

void	UpdateThrowMatrix (TMatrixDSym *cov)

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.

TMatrixDSym *	GetThrowMatrix () const
	Get matrix used for step proposal.

double	GetThrowMatrix (const int i, const int j) const
	Get matrix used for step proposal.

TMatrixD *	GetThrowMatrix_CholDecomp () const
	Get the Cholesky decomposition of the throw matrix.

TH2D *	GetCorrelationMatrix ()
	KS: Convert covariance matrix to correlation matrix and return TH2D which can be used for fancy plotting.

const double *	RetPointer (const int iParam)
	DB Pointer return to param position.

const std::vector< double > &	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()

int	GetNumParams () const
	Get total number of parameters.

std::vector< double >	GetPreFitValues () const
	Get the pre-fit values of the parameters.

std::vector< double >	GetProposed () const
	Get vector of all proposed parameter values.

double	GetParProp (const int i) const
	Get proposed parameter value.

double	GetParCurr (const int i) const
	Get current parameter value.

double	GetParInit (const int i) const
	Get prior parameter value.

double	GetUpperBound (const int i) const
	Get upper parameter bound in which it is physically valid.

double	GetLowerBound (const int i) const
	Get lower parameter bound in which it is physically valid.

double	GetIndivStepScale (const int ParameterIndex) const
	Get individual step scale for selected parameter.

double	GetGlobalStepScale () const
	Get global step scale for covariance object.

int	GetNParameters () const
	Get number of params which will be different depending if using Eigen decomposition or not.

void	PrintNominal () const
	Print prior value for every parameter.

void	PrintNominalCurrProp () const
	Print prior, current and proposed value for each parameter.

void	PrintParameters () const

void	PrintIndivStepScale () const
	Print step scale for each parameter.

virtual void	ProposeStep ()
	Generate a new proposed state.

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

void	CorrelateSteps () _noexcept_
	Use Cholesky throw matrix for better step proposal.

void	UpdateAdaptiveCovariance ()
	Method to update adaptive MCMC [12].

void	AcceptStep () _noexcept_
	Accepted this step.

void	ToggleFixAllParameters ()
	fix parameters at prior values

void	ToggleFixParameter (const int i)
	fix parameter at prior values

void	ToggleFixParameter (const std::string &name)
	Fix parameter at prior values.

bool	IsParameterFixed (const int i) const
	Is parameter fixed or not.

bool	IsParameterFixed (const std::string &name) const
	Is parameter fixed or not.

void	ConstructPCA (const double eigen_threshold, int FirstPCAdpar, int LastPCAdpar)
	CW: Calculate eigen values, prepare transition matrices and remove param based on defined threshold.

bool	IsPCA () const
	is PCA, can use to query e.g. LLH scans

YAML::Node	GetConfig () const
	Getter to return a copy of the YAML node.

adaptive_mcmc::AdaptiveMCMCHandler *	GetAdaptiveHandler () const
	Get pointer for AdaptiveHandler.

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.

PCAHandler *	GetPCAHandler () const
	Get pointer for PCAHandler.

Protected Member Functions
void	Print ()
	Print information about the whole object once it is set.

void	PrintGlobablInfo ()
	Prints general information about the ParameterHandler object.

void	PrintNormParams ()
	Prints normalization parameters.

void	PrintSplineParams ()
	Prints spline parameters.

void	PrintFunctionalParams ()
	Prints functional parameters.

void	PrintOscillationParams ()
	Prints oscillation parameters.

void	PrintParameterGroups ()
	Prints groups of parameters.

void	CheckCorrectInitialisation ()
	KS: Check if matrix is correctly initialised.

template<typename FilterFunc , typename ActionFunc >
void	IterateOverParams (const std::string &SampleName, FilterFunc filter, ActionFunc action)
	Iterates over parameters and applies a filter and action function.

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

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.

NormParameter	GetNormParameter (const YAML::Node &param, const int Index)
	Get Norm params.

OscillationParameter	GetOscillationParameters (const YAML::Node &param, const int Index)
	Get Osc params.

FunctionalParameter	GetFunctionalParameters (const YAML::Node &param, const int Index)
	Get Func params.

SplineParameter	GetSplineParameter (const YAML::Node &param, const int Index)
	Get Spline params.

void	GetBaseParameter (const YAML::Node &param, const int Index, TypeParameterBase &Parameter)
	Fill base parameters.

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.

Protected Member Functions inherited from ParameterHandlerBase
void	Init (const std::string &name, const std::string &file)
	Initialisation of the class using matrix from root file.

void	Init (const std::vector< std::string > &YAMLFile)
	Initialisation of the class using config.

void	ReserveMemory (const int size)
	Initialise vectors with parameters information.

void	MakePosDef (TMatrixDSym *cov=nullptr)
	Make matrix positive definite by adding small values to diagonal, necessary for inverting matrix.

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)

void	SetThrowMatrixFromFile (const std::string &matrix_file_name, const std::string &matrix_name, const std::string &means_name)
	sets throw matrix from a file

bool	AppliesToSample (const int SystIndex, const std::string &SampleName) const
	Check if parameter is affecting given sample name.

void	FlipParameterValue (const int index, const double FlipPoint)
	KS: Flip parameter around given value, for example mass ordering around 0.

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.

void	EnableSpecialProposal (const YAML::Node &param, const int Index)
	Enable special proposal.

void	SpecialStepProposal ()
	Perform Special Step Proposal.

Protected Attributes
std::vector< SystType >	_fParamType
	Type of parameter like norm, spline etc.

std::vector< std::string >	_fSplineNames
	Name of spline in TTree (TBranch),.

std::vector< std::string >	_ParameterGroup
	KS: Allow to group parameters for example to affect only cross-section or only flux etc.

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.

std::vector< SplineParameter >	SplineParams
	Vector containing info for normalisation systematics.

std::vector< NormParameter >	NormParams
	Vector containing info for normalisation systematics.

std::vector< FunctionalParameter >	FuncParams
	Vector containing info for functional systematics.

std::vector< OscillationParameter >	OscParams
	Vector containing info for functional systematics.

Protected Attributes inherited from ParameterHandlerBase
bool	doSpecialStepProposal
	Check if any of special step proposal were enabled.

const std::string	inputFile
	The input root file we read in.

std::string	matrixName
	Name of cov matrix.

TMatrixDSym *	covMatrix
	The covariance matrix.

TMatrixDSym *	invCovMatrix
	The inverse covariance matrix.

std::vector< std::vector< double > >	InvertCovMatrix
	KS: Same as above but much faster as TMatrixDSym cache miss.

std::vector< std::unique_ptr< TRandom3 > >	random_number
	KS: Set Random numbers for each thread so each thread has different seed.

double *	randParams
	Random number taken from gaussian around prior error used for corr_throw.

double *	corr_throw
	Result of multiplication of Cholesky matrix and randParams.

double	_fGlobalStepScale
	Global step scale applied to all params in this class.

int	PrintLength
	KS: This is used when printing parameters, sometimes we have super long parameters name, we want to flexibly adjust couts.

std::vector< std::string >	_fNames
	ETA _fNames is set automatically in the covariance class to be something like xsec_i, this is currently to make things compatible with the Diagnostic tools.

std::vector< std::string >	_fFancyNames
	Fancy name for example rather than xsec_0 it is MAQE, useful for human reading.

YAML::Node	_fYAMLDoc
	Stores config describing systematics.

int	_fNumPar
	Number of systematic parameters.

std::vector< double >	_fPreFitValue
	Parameter value dictated by the prior model. Based on it penalty term is calculated.

std::vector< double >	_fCurrVal
	Current value of the parameter.

std::vector< double >	_fPropVal
	Proposed value of the parameter.

std::vector< double >	_fError
	Prior error on the parameter.

std::vector< double >	_fLowBound
	Lowest physical bound, parameter will not be able to go beyond it.

std::vector< double >	_fUpBound
	Upper physical bound, parameter will not be able to go beyond it.

std::vector< double >	_fIndivStepScale
	Individual step scale used by MCMC algorithm.

std::vector< bool >	_fFlatPrior
	Whether to apply flat prior or not.

std::vector< std::vector< std::string > >	_fSampleNames
	Tells to which samples object param should be applied.

TMatrixDSym *	throwMatrix
	Matrix which we use for step proposal before Cholesky decomposition (not actually used for step proposal)

TMatrixD *	throwMatrix_CholDecomp
	Matrix which we use for step proposal after Cholesky decomposition.

double **	throwMatrixCholDecomp
	Throw matrix that is being used in the fit, much faster as TMatrixDSym cache miss.

bool	pca
	perform PCA or not

bool	use_adaptive
	Are we using AMCMC?

std::unique_ptr< PCAHandler >	PCAObj
	Struct containing information about PCA.

std::unique_ptr< adaptive_mcmc::AdaptiveMCMCHandler >	AdaptiveHandler
	Struct containing information about adaption.

std::unique_ptr< ParameterTunes >	Tunes
	Struct containing information about adaption.

std::vector< int >	FlipParameterIndex
	Indices of parameters with flip symmetry.

std::vector< double >	FlipParameterPoint
	Central points around which parameters are flipped.

std::vector< int >	CircularBoundsIndex
	Indices of parameters with circular bounds.

std::vector< std::pair< double, double > >	CircularBoundsValues
	Circular bounds for each parameter (lower, upper)

Detailed Description

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

See also: For more details, visit the Wiki.

Author: Dan Barrow; Ed Atkin; Kamil Skwarczynski

Definition at line 12 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.

               : ParameterHandlerBase(YAMLFile, name, 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");
  InitParams();
  // Print
  Print();
}

◆ ~ParameterHandlerGeneric()

ParameterHandlerGeneric::~ParameterHandlerGeneric ( )

Destructor.

Definition at line 108 of file ParameterHandlerGeneric.cpp.

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

Member Function Documentation

◆ CheckCorrectInitialisation()

void ParameterHandlerGeneric::CheckCorrectInitialisation ( )

protected

KS: Check if matrix is correctly initialised.

Definition at line 643 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) {
    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];
        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;
    }
  };
 
  // KS: Checks if there are no duplicates in fancy names etc, this can happen if we merge configs etc
  CheckForDuplicates(_fFancyNames, "_fFancyNames");
  CheckForDuplicates(_fSplineNames, "_fSplineNames");
}

◆ 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 744 of file ParameterHandlerGeneric.cpp.

                                                                    {
// ********************************************
  TFile* outputFile = new TFile(Name.c_str(), "RECREATE");
 
  TObjArray* xsec_param_names = new TObjArray();
  TObjArray* xsec_spline_interpolation = new TObjArray();
  TObjArray* xsec_spline_names = new TObjArray();
 
  TVectorD* xsec_param_prior = new TVectorD(_fNumPar);
  TVectorD* xsec_flat_prior = new TVectorD(_fNumPar);
  TVectorD* xsec_stepscale = new TVectorD(_fNumPar);
  TVectorD* xsec_param_lb = new TVectorD(_fNumPar);
  TVectorD* xsec_param_ub = new TVectorD(_fNumPar);
 
  TVectorD* xsec_param_knot_weight_lb = new TVectorD(_fNumPar);
  TVectorD* xsec_param_knot_weight_ub = new TVectorD(_fNumPar);
  TVectorD* xsec_error = new TVectorD(_fNumPar);
 
  for(int i = 0; i < _fNumPar; ++i)
  {
    TObjString* nameObj = new TObjString(_fFancyNames[i].c_str());
    xsec_param_names->AddLast(nameObj);
 
    TObjString* splineType = new TObjString("TSpline3");
    xsec_spline_interpolation->AddLast(splineType);
 
    TObjString* splineName = new TObjString("");
    xsec_spline_names->AddLast(splineName);
 
    (*xsec_param_prior)[i] = _fPreFitValue[i];
    (*xsec_flat_prior)[i] = _fFlatPrior[i];
    (*xsec_stepscale)[i] = _fIndivStepScale[i];
    (*xsec_error)[i] = _fError[i];
 
    (*xsec_param_lb)[i] = _fLowBound[i];
    (*xsec_param_ub)[i] = _fUpBound[i];
 
    //Default values
    (*xsec_param_knot_weight_lb)[i] = -9999;
    (*xsec_param_knot_weight_ub)[i] = +9999;
  }
 
  for (auto &pair : _fSystToGlobalSystIndexMap[SystType::kSpline]) {
    auto &SplineIndex = pair.first;
    auto &SystIndex = pair.second;
 
    (*xsec_param_knot_weight_lb)[SystIndex] = SplineParams.at(SplineIndex)._SplineKnotLowBound;
    (*xsec_param_knot_weight_ub)[SystIndex] = SplineParams.at(SplineIndex)._SplineKnotUpBound;
 
    TObjString* splineType = new TObjString(SplineInterpolation_ToString(SplineParams.at(SplineIndex)._SplineInterpolationType).c_str());
    xsec_spline_interpolation->AddAt(splineType, SystIndex);
 
    TObjString* splineName = new TObjString(_fSplineNames[SplineIndex].c_str());
    xsec_spline_names->AddAt(splineName, SystIndex);
  }
  xsec_param_names->Write("xsec_param_names", TObject::kSingleKey);
  delete xsec_param_names;
  xsec_spline_interpolation->Write("xsec_spline_interpolation", TObject::kSingleKey);
  delete xsec_spline_interpolation;
  xsec_spline_names->Write("xsec_spline_names", TObject::kSingleKey);
  delete xsec_spline_names;
 
  xsec_param_prior->Write("xsec_param_prior");
  delete xsec_param_prior;
  xsec_flat_prior->Write("xsec_flat_prior");
  delete xsec_flat_prior;
  xsec_stepscale->Write("xsec_stepscale");
  delete xsec_stepscale;
  xsec_param_lb->Write("xsec_param_lb");
  delete xsec_param_lb;
  xsec_param_ub->Write("xsec_param_ub");
  delete xsec_param_ub;
 
  xsec_param_knot_weight_lb->Write("xsec_param_knot_weight_lb");
  delete xsec_param_knot_weight_lb;
  xsec_param_knot_weight_ub->Write("xsec_param_knot_weight_ub");
  delete xsec_param_knot_weight_ub;
  xsec_error->Write("xsec_error");
  delete xsec_error;
 
  covMatrix->Write("xsec_cov");
  TH2D* CorrMatrix = GetCorrelationMatrix();
  CorrMatrix->Write("hcov");
  delete CorrMatrix;
 
  outputFile->Close();
  delete outputFile;
 
  MACH3LOG_INFO("Finished dumping ParameterHandler object");
}

◆ GetBaseParameter()

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

inlineprotected

Fill base parameters.

Parameters

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

Definition at line 218 of file ParameterHandlerGeneric.cpp.

                                                                                                                   {
// ********************************************
  // KS: For now we don't use so avoid compilation error
  (void) param;
 
  Parameter.name = GetParFancyName(Index);
 
  // Set the global parameter index of the normalisation parameter
  Parameter.index = Index;
}

◆ GetFunctionalParameters()

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

inlineprotected

Get Func params.

Parameters

param	Yaml node describing param
Index	Global parameter index

Definition at line 292 of file ParameterHandlerGeneric.cpp.

                                                                                                           {
// ********************************************
  FunctionalParameter func;
  GetBaseParameter(param, Index, func);
 
  func.pdgs = GetFromManager<std::vector<int>>(param["NeutrinoFlavour"], std::vector<int>(), __FILE__ , __LINE__);
  func.targets = GetFromManager<std::vector<int>>(param["TargetNuclei"], std::vector<int>(), __FILE__ , __LINE__);
  func.modes = GetFromManager<std::vector<int>>(param["Mode"], std::vector<int>(), __FILE__ , __LINE__);
  func.preoscpdgs = GetFromManager<std::vector<int>>(param["NeutrinoFlavourUnosc"], std::vector<int>(), __FILE__ , __LINE__);
 
  // HH - Copied from GetXsecNorm
  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 {}", func.name);
        throw MaCh3Exception(__FILE__, __LINE__);
      }
    }//KinVar_i
    func.KinematicVarStr = TempKinematicStrings;
    func.Selection = TempKinematicBounds;
  }
  func.valuePtr = RetPointer(Index);
  return func;
}

◆ GetNormParameter()

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

inlineprotected

Get Norm params.

Parameters

param	Yaml node describing param
Index	Global parameter index

ETA size 0 to mean apply to all Ultimately all this information ends up in the @NormParams vector

Definition at line 162 of file ParameterHandlerGeneric.cpp.

                                                                                              {
// ********************************************
  NormParameter norm;
 
  GetBaseParameter(param, Index, norm);
 
  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__);
  }
  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 {}", norm.name);
        throw MaCh3Exception(__FILE__, __LINE__);
      }
    }//KinVar_i
    norm.KinematicVarStr = TempKinematicStrings;
    norm.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(norm.KinematicVarStr.size() > 0) HasKinBounds = true;
 
  norm.hasKinBounds = HasKinBounds;
  //End of kinematic bound checking
 
  return norm;
}

◆ GetOscillationParameters()

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

inlineprotected

Get Osc params.

Parameters

param	Yaml node describing param
Index	Global parameter index

Definition at line 332 of file ParameterHandlerGeneric.cpp.

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

◆ 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 40 of file ParameterHandlerGeneric.h.

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

◆ GetSplineParameter()

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

inlineprotected

Get Spline params.

Parameters

param	Yaml node describing param
Index	Global parameter index

Definition at line 263 of file ParameterHandlerGeneric.cpp.

                                                                                                  {
// ********************************************
  SplineParameter Spline;
 
  GetBaseParameter(param, Index, Spline);
  //Now get the Spline interpolation type
  if (param["SplineInformation"]["InterpolationType"]){
    for(int InterpType = 0; InterpType < kSplineInterpolations ; ++InterpType){
      if(param["SplineInformation"]["InterpolationType"].as<std::string>() == SplineInterpolation_ToString(SplineInterpolation(InterpType)))
        Spline._SplineInterpolationType = SplineInterpolation(InterpType);
    }
  } else { //KS: By default use TSpline3
    Spline._SplineInterpolationType = kTSpline3;
  }
  Spline._SplineKnotUpBound = GetFromManager<double>(param["SplineInformation"]["SplineKnotUpBound"], M3::DefSplineKnotUpBound, __FILE__ , __LINE__);
  Spline._SplineKnotLowBound = GetFromManager<double>(param["SplineInformation"]["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(param["SplineInformation"]["Mode"], std::vector<int>(), __FILE__ , __LINE__);
 
  return Spline;
}

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

◆ InitParametersTypeFromConfig()

void ParameterHandlerGeneric::InitParametersTypeFromConfig ( )

inlineprotected

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 26 of file ParameterHandlerGeneric.cpp.

                                                           {
// ********************************************
  _fSystToGlobalSystIndexMap.resize(SystType::kSystTypes);
 
  _fParamType = std::vector<SystType>(_fNumPar);
  _ParameterGroup = 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__);
 
    //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.find(SystType_ToString(SystType::kSpline)) != std::string::npos)
    {
      //Set param type
      _fParamType[i] = SystType::kSpline;
      // Fill Spline info
      SplineParams.push_back(GetSplineParameter(param["Systematic"], i));
 
      if (param["Systematic"]["SplineInformation"]["SplineName"]) {
        _fSplineNames.push_back(param["Systematic"]["SplineInformation"]["SplineName"].as<std::string>());
      }
 
      //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(param["Systematic"]["Type"].as<std::string>() == 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(param["Systematic"]["Type"].as<std::string>() == 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(param["Systematic"]["Type"].as<std::string>() == 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: {}", param["Systematic"]["Type"].as<std::string>());
      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
 
  //Add a sanity check,
  if(_fSplineNames.size() != ParamCounter[SystType::kSpline]){
    MACH3LOG_ERROR("_fSplineNames is of size {} but found {} spline parameters", _fSplineNames.size(), ParamCounter[SystType::kSpline]);
    throw MaCh3Exception(__FILE__, __LINE__);
  }
  //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();
}

◆ InitParams()

void ParameterHandlerGeneric::InitParams ( )

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 424 of file ParameterHandlerGeneric.cpp.

                                         {
// ********************************************
  for (int i = 0; i < _fNumPar; ++i) {
    //ETA - set the name to be xsec_% as this is what ProcessorMCMC expects
    _fNames[i] = "xsec_"+std::to_string(i);
 
    // KS: Plenty
    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__ );
      }
    }
    // Set ParameterHandler parameters (Curr = current, Prop = proposed, Sigma = step)
    _fCurrVal[i] = _fPreFitValue[i];
    _fPropVal[i] = _fCurrVal[i];
  }
  Randomize();
  //KS: Transfer the starting parameters to the PCA basis, you don't want to start with zero..
  if (pca) {
    PCAObj->SetInitialParameters(_fIndivStepScale);
  }
}

◆ IterateOverParams()

template<typename FilterFunc , typename ActionFunc >

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

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

◆ Print()

void ParameterHandlerGeneric::Print ( )

protected

Print information about the whole object once it is set.

Definition at line 453 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 ( )

protected

Prints functional parameters.

Definition at line 592 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 ( )

protected

Prints general information about the ParameterHandler object.

Definition at line 477 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 ( )

protected

Prints normalization parameters.

Definition at line 497 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 ( )

protected

Prints oscillation parameters.

Definition at line 608 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 ( )

protected

Prints groups of parameters.

Definition at line 624 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 ( )

protected

Prints spline parameters.

Definition at line 570 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), "|",
                  _fSplineNames[SplineIndex], "|",
                  SplineInterpolation_ToString(GetParSplineInterpolation(SplineIndex)), "|",
                  GetParSplineKnotLowerBound(SplineIndex), "|",
                  GetParSplineKnotUpperBound(SplineIndex), "|");
  }
  MACH3LOG_INFO("=====================================================================================================================================================================");
}

Member Data Documentation

◆ _fParamType

std::vector<SystType> ParameterHandlerGeneric::_fParamType

protected

Type of parameter like norm, spline etc.

Definition at line 206 of file ParameterHandlerGeneric.h.

◆ _fSplineNames

std::vector<std::string> ParameterHandlerGeneric::_fSplineNames

protected

Name of spline in TTree (TBranch),.

Definition at line 209 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 215 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 212 of file ParameterHandlerGeneric.h.

◆ FuncParams

std::vector<FunctionalParameter> ParameterHandlerGeneric::FuncParams

protected

Vector containing info for functional systematics.

Definition at line 224 of file ParameterHandlerGeneric.h.

◆ NormParams

std::vector<NormParameter> ParameterHandlerGeneric::NormParams

protected

Vector containing info for normalisation systematics.

Definition at line 221 of file ParameterHandlerGeneric.h.

◆ OscParams

std::vector<OscillationParameter> ParameterHandlerGeneric::OscParams

protected

Vector containing info for functional systematics.

Definition at line 227 of file ParameterHandlerGeneric.h.

◆ SplineParams

std::vector<SplineParameter> ParameterHandlerGeneric::SplineParams

protected

Vector containing info for normalisation systematics.

Definition at line 218 of file ParameterHandlerGeneric.h.

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

Parameters/ParameterHandlerGeneric.h
Parameters/ParameterHandlerGeneric.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ParameterHandlerGeneric()

◆ ~ParameterHandlerGeneric()

Member Function Documentation

◆ CheckCorrectInitialisation()

◆ DumpMatrixToFile()

◆ GetBaseParameter()

◆ GetFunctionalParameters()

◆ GetNormParameter()

◆ GetOscillationParameters()

◆ GetParSplineInterpolation()

◆ GetSplineParameter()

◆ GetTypeParamsFromSampleName()

◆ InitParametersTypeFromConfig()

◆ InitParams()

◆ IterateOverParams()

◆ Print()

◆ PrintFunctionalParams()

◆ PrintGlobablInfo()

◆ PrintNormParams()

◆ PrintOscillationParams()

◆ PrintParameterGroups()

◆ PrintSplineParams()

Member Data Documentation

◆ _fParamType

◆ _fSplineNames

◆ _fSystToGlobalSystIndexMap

◆ _ParameterGroup

◆ FuncParams

◆ NormParams

◆ OscParams

◆ SplineParams