Helper class for configuring and evaluating multicanonical umbrella weights. More...

#include <Fitters/Algorithms/MulticanonicalMCMCHandler.h>

Collaboration diagram for MulticanonicalMCMCHandler:

Public Member Functions
	MulticanonicalMCMCHandler ()
	Constructor. More...

virtual	~MulticanonicalMCMCHandler ()
	Destructor. More...

void	FindOscCovParams (const std::vector< ParameterHandlerBase * > &systematics)
	Locate the systematic object which contains the parameters used by the handler. Stores the parameter indices. More...

void	AdjustUmbrellaStepScale (const std::vector< ParameterHandlerBase * > &systematics)
	Adjust the parameter-of-interest's step scale according to the width of the umbrella bias function. More...

void	InitializeMulticanonicalHandlerConfig (Manager fitMan, std::vector< ParameterHandlerBase > &systematics)
	Read multicanonical configuration from the yaml via manager and initialise handler state. More...

void	InitializeMulticanonicalParams (std::vector< ParameterHandlerBase * > &systematics)
	Initialise the starting values used by the multicanonical parameter handling. More...

double	GetMulticanonicalWeight () const
	Compute the multicanonical penalty for the configured bias mode. More...

double	GetMulticanonicalWeightSpline (double deltacp, double delm23) const
	Compute the multicanonical penalty using a spline. More...

double	GetMulticanonicalWeightGaussian (double deltacp) const
	Compute a Gaussian multicanonical penalty. More...

double	GetMulticanonicalWeightTripleGaussian (double deltacp) const
	Compute a triple-Gaussian multicanonical penalty. More...

double	GetMulticanonicalWeightVonMises (double deltacp) const
	Compute a von Mises multicanonical penalty. More...

double	GetMulticanonicalWeightGenGaussian (double deltacp) const
	Compute a generalised-Gaussian multicanonical penalty. More...

double	circularDistance (double x, double mean) const
	Compute the circular distance between two angles. More...

double	generalisedGaussian2 (double x, double mean, double width) const
	Wraps the generalised gaussian function for a given x, mean, and width. Required to handle the wrapping of the parameter space at 2pi. More...

Public Attributes
int	oscCovVar
	Index of the oscillation-covariance systematic in the current fit. More...

std::string	multicanonicalVarName
	Parameter name used for the multicanonical weight, most often delta_cp. More...

int	multicanonicalVar
	Parameter index used for the multicanonical weight, most often delta_cp. More...

int	multicanonicalVar_dm23
	Parameter index used for the multicanonical delm2_23 weight. More...

const M3::float_t *	multicanonicalVarValue
	Pointer to value of parameter vale used for multicanonical weight, most often delta_cp. More...

const M3::float_t *	multicanonicalVar_dm23_value
	Pointer to value of delm2_23 weight used for multicanonical weight. More...

M3::BiasFunction	umbrellaBiasFunction
	Selected bias function for multicanonical weights. More...

std::string	umbrellaBiasFunctionName
	Configured bias function name for logging. More...

bool	multicanonicalSpline
	Toggle for spline-based multicanonical weights. More...

Protected Attributes
double	multicanonicalBeta
	Global scale factor applied to the multicanonical penalty. 1 is full strength, 0 is no penalty. More...

TSpline3 *	dcp_spline_IO
	Spline for the IO branch, if spline mode is enabled. More...

TSpline3 *	dcp_spline_NO
	Spline for the NO branch, if spline mode is enabled. More...

double	umbrellaMean
	Umbrella centre used for the current configuration. More...

double	umbrellaWidth
	Umbrella width used for the current configuration. More...

int	umbrellaNumber
	Number of total umbrellas used for the current configuration. More...

bool	umbrellaOverlapMode
	Toggle for deriving umbrella widths from a desired # of sigma overlaps between umbrellas. More...

double	umbrellaSigmaOverlap
	Requested overlap for evenly spaced umbrellas. More...

bool	umbrellaAdjustStepScale
	Toggle for rescaling the step size based on the umbrella width. More...

double	umbrellaStepScaleFactor
	Additional scale factor applied when rescaling the step size. This is for fine tuning. More...

bool	flipWindow
	Optional flip-window control. More...

double	vonMises_kappa
	Von Mises kappa parameter. Analogue of sigma for a gaussian. More...

double	vonMises_I0_kappa
	Cached I0(kappa) value for the von Mises form. More...

Detailed Description

Helper class for configuring and evaluating multicanonical umbrella weights.

this method is used to bias the MCMC sampling of chains to particular regions of the parameter space The method relies on a bias function defined via a yaml configuration file in experimental specific code With a bias function defined chains run as normal and are combined after the fact using the information stored in the chains saved yaml configuration file.

[29]

Author: David Riley

The method is visualised below:

/// ///

Definition at line 72 of file MulticanonicalMCMCHandler.h.

Constructor & Destructor Documentation

◆ MulticanonicalMCMCHandler()

MulticanonicalMCMCHandler::MulticanonicalMCMCHandler ( )

Constructor.

Definition at line 11 of file MulticanonicalMCMCHandler.cpp.

                                                      {
   // Initialize member variables with defaults
   dcp_spline_IO = nullptr;
   dcp_spline_NO = nullptr;
   flipWindow = false;
  
   vonMises_kappa = -1.0;
   vonMises_I0_kappa = -1.0;
 }

◆ ~MulticanonicalMCMCHandler()

MulticanonicalMCMCHandler::~MulticanonicalMCMCHandler ( )

virtual

Destructor.

Definition at line 22 of file MulticanonicalMCMCHandler.cpp.

                                                       {
  
 }

Member Function Documentation

◆ AdjustUmbrellaStepScale()

void MulticanonicalMCMCHandler::AdjustUmbrellaStepScale ( const std::vector< ParameterHandlerBase * > & systematics )

Adjust the parameter-of-interest's step scale according to the width of the umbrella bias function.

This is used to adjust the step scale of the parameter to keep the size of the step scale relative to the new biased space the chain sees the same. Current assumes that your are sampling delta cp (ie circular on 2pi)

Todo:: grab the step scale from the object directly and update based on the radtio to the umbrella width, removing assumption that its dcp

Definition at line 180 of file MulticanonicalMCMCHandler.cpp.

                                                                                                            {
   if (umbrellaAdjustStepScale) {
     MACH3LOG_INFO("Adjusting umbrella step scale to keep ratio of step scale to multicanonical sigma constant");
     MACH3LOG_INFO("Setting umbrella step scale factor to {}", umbrellaStepScaleFactor);
     double stepScale = (umbrellaWidth * umbrellaStepScaleFactor) / (2.0 * TMath::Pi());
     MACH3LOG_INFO("Setting individual step scale for multicanonical separate to {}", stepScale);
     systematics[oscCovVar]->SetIndivStepScale(multicanonicalVar, stepScale);
     MACH3LOG_INFO("Setting individual step scale for {} systematic to {}", multicanonicalVar, stepScale);
   } else {
     MACH3LOG_INFO("Not adjusting umbrella step scale, using value in OscCov config");
   }
 }

◆ circularDistance()

double MulticanonicalMCMCHandler::circularDistance	(	double	x,
		double	mean
	)		const

Compute the circular distance between two angles.

This is used to calculate the distance between two angles in a circular space, such as delta_cp. It returns the shortest distance between the two angles, taking into account the wrapping at 2pi.

Definition at line 265 of file MulticanonicalMCMCHandler.cpp.

                                                                               {
   return std::atan2(std::sin(x - mean), std::cos(x - mean));
 }

◆ FindOscCovParams()

void MulticanonicalMCMCHandler::FindOscCovParams ( const std::vector< ParameterHandlerBase * > & systematics )

Locate the systematic object which contains the parameters used by the handler. Stores the parameter indices.

Definition at line 33 of file MulticanonicalMCMCHandler.cpp.

                                                                                                     {
   bool foundVariableOfInterest = false;
   bool foundDelm23 = false;
  
   // Loop over the systematics and find the osc_cov systematic and the delta_cp parameter number
   MACH3LOG_INFO("Looping over systematics to find {} parameter", multicanonicalVarName);
   MACH3LOG_INFO("Number of systematics: {}", systematics.size());
  
   for (size_t iCov = 0; iCov < systematics.size(); iCov++){
     auto* syst = systematics[static_cast<int>(iCov)];
     for (int i = 0; i < syst->GetNumParams(); i++) {
       if (syst->GetParName(i) == multicanonicalVarName) {
         MACH3LOG_INFO("Found {} parameter in systematic {} at index {}", multicanonicalVarName, syst->GetName(), i);
         oscCovVar = static_cast<int>(iCov);
         multicanonicalVar = i;
         multicanonicalVarValue = syst->RetPointer(i);
         foundVariableOfInterest = true;
       }
       if (syst->GetParName(i) == "delm2_23") {
         MACH3LOG_INFO("Found delm2_23 parameter in systematic {} at index {}", syst->GetName(), i);
         multicanonicalVar_dm23 = i;
         multicanonicalVar_dm23_value = syst->RetPointer(i);
         foundDelm23 = true;
       }
     }  
   }
  
   // if we didn't find both parameters we need to throw
   if (!foundVariableOfInterest) {
     MACH3LOG_ERROR("Could not find {} parameter in osc_cov systematic", multicanonicalVarName);
     throw MaCh3Exception(__FILE__, __LINE__);
   }
   if (!foundDelm23) {
     MACH3LOG_ERROR("Could not find delm2_23 parameter in osc_cov systematic");
     throw MaCh3Exception(__FILE__, __LINE__, "Could not find delm2_23 parameter in osc_cov systematic");
   }
 }

◆ generalisedGaussian2()

double MulticanonicalMCMCHandler::generalisedGaussian2	(	double	x,
		double	mean,
		double	width
	)		const

Wraps the generalised gaussian function for a given x, mean, and width. Required to handle the wrapping of the parameter space at 2pi.

Definition at line 257 of file MulticanonicalMCMCHandler.cpp.

                                                                                                 {
   constexpr int n = 2; // this controls the tightness of the gaussian fixed at 2 for now due to normalisation
   // 1/4 * Gamma(1/4) = 0.906402477055 (this factor from 2n/Gamma(1/2n) for n=2)
   const double normFactor = 1 / ((M3::UmbrellaGaussianNormFactor) * 2 * std::sqrt(2) * width); // the normalisation is a little ugly (uses gamma functions), im just going to hardcode them for now
   double likelihood = normFactor * std::exp(-std::pow((std::pow(x - mean, 2) / (2 * std::pow(width, 2))), n));
   return likelihood;
 }

◆ GetMulticanonicalWeight()

double MulticanonicalMCMCHandler::GetMulticanonicalWeight ( ) const

Compute the multicanonical penalty for the configured bias mode.

This wraps the various bias function implementations and returns the appropriate penalty

Returns: Returns the log likelihood penalty for the selected bias function at the proposed parameter values.

Definition at line 221 of file MulticanonicalMCMCHandler.cpp.

                                                                 {
   auto deltacp = *multicanonicalVarValue;
  
   if (multicanonicalSpline) {
     auto delm23 = *multicanonicalVar_dm23_value;
     return GetMulticanonicalWeightSpline(deltacp, delm23);
   }
  
   switch (umbrellaBiasFunction) {
   case M3::BiasFunction::kGaussian:
     return GetMulticanonicalWeightGaussian(deltacp);
   case M3::BiasFunction::kVonMises:
     return GetMulticanonicalWeightVonMises(deltacp);
   case M3::BiasFunction::kGeneralisedGaussian:
     return GetMulticanonicalWeightGenGaussian(deltacp);
   }
   return M3::_BAD_DOUBLE_;
 }

◆ GetMulticanonicalWeightGaussian()

double MulticanonicalMCMCHandler::GetMulticanonicalWeightGaussian ( double deltacp ) const

Compute a Gaussian multicanonical penalty.

Definition at line 250 of file MulticanonicalMCMCHandler.cpp.

                                                                                       {
   const double inv_sqrt_2pi = 1 / std::sqrt(2 * TMath::Pi());
   const double neg_half_sigma_sq = -1 / (2 * umbrellaWidth * umbrellaWidth);
   // return the log likelihood, ie the log of the normalised gaussian
   return (-std::log(inv_sqrt_2pi * (1 / umbrellaWidth) * std::exp(neg_half_sigma_sq * (deltacp - umbrellaMean) * (deltacp - umbrellaMean)))) * (multicanonicalBeta);
 }

◆ GetMulticanonicalWeightGenGaussian()

double MulticanonicalMCMCHandler::GetMulticanonicalWeightGenGaussian ( double deltacp ) const

Compute a generalised-Gaussian multicanonical penalty.

the generalised gaussian is like a gaussian with an extra factor of n on the exponent of the gaussian. This allows for a stronger constraint in the tails of the distribution, more like a tophat function. The normalisation is a little ugly and uses gamma functions, so for now it is hardcoded to n=2. This is the current recommended configuration for umbrella sampling.

Todo:

implement the wrapping with circular distance function to avoid the need to calculate the weight multiple times for each parameter to ensure it receives a bias even when it jumps the boundary

implement the normalisation for n != 2, and allow n to be set in the yaml configuration file

Definition at line 269 of file MulticanonicalMCMCHandler.cpp.

                                                                                          {
   // implementation of the generalised gaussian as a bias function
   // for now with a fixed n = 2 for simplicity
   double g0 = generalisedGaussian2(deltacp, umbrellaMean, umbrellaWidth); // these two repeats are required for wrapping the gaussian around -pi and pi
   double g1 = generalisedGaussian2(deltacp, umbrellaMean - 2 * TMath::Pi(), umbrellaWidth);
   double g2 = generalisedGaussian2(deltacp, umbrellaMean + 2 * TMath::Pi(), umbrellaWidth);
  
   MACH3LOG_TRACE("g0: {}, g1: {}, g2: {}", g0, g1, g2);
   return -std::log(g0 + g1 + g2) * (multicanonicalBeta);
 }

◆ GetMulticanonicalWeightSpline()

double MulticanonicalMCMCHandler::GetMulticanonicalWeightSpline	(	double	deltacp,
		double	delm23
	)		const

Compute the multicanonical penalty using a spline.

Definition at line 240 of file MulticanonicalMCMCHandler.cpp.

                                                                                                    {
   if (delm23 < 0) {
     double dcp_spline_val = dcp_spline_IO->Eval(deltacp);
     return -(-std::log(dcp_spline_val) + std::log(dcp_spline_IO->Eval(-TMath::Pi() / 2))) * (multicanonicalBeta); // do I want this offset?? does it matter?
   } else {
     double dcp_spline_val = dcp_spline_NO->Eval(deltacp);
     return -(-std::log(dcp_spline_val) + std::log(dcp_spline_NO->Eval(-TMath::Pi() / 2))) * (multicanonicalBeta);
   }
 }

◆ GetMulticanonicalWeightTripleGaussian()

double MulticanonicalMCMCHandler::GetMulticanonicalWeightTripleGaussian ( double deltacp ) const

Compute a triple-Gaussian multicanonical penalty.

This was mostly for testing the first implementation, probably not used anymore.

delta_cp_log_likelihood = -TMath::Log(TMath::Gaus(deltacp,TMath::Pi(),1,kTRUE)+TMath::Gaus(deltacp,0,1,kTRUE)+TMath::Gaus(deltacp,-TMath::Pi(),1,kTRUE));

Definition at line 281 of file MulticanonicalMCMCHandler.cpp.

                                                                                             {
   // precalculated constants
   constexpr double inv_sqrt_2pi = 0.3989422804014337;
   double sigma = umbrellaWidth;
   const double neg_half_sigma_sq = -1 / (2 * sigma * sigma);
   // three gaussians centered at -pi, 0, pi with sigma pre-defined above
   double exp1 = std::exp(neg_half_sigma_sq * (deltacp - TMath::Pi()) * (deltacp - TMath::Pi()));
   double exp2 = std::exp(neg_half_sigma_sq * (deltacp) * (deltacp));
   double exp3 = std::exp(neg_half_sigma_sq * (deltacp + TMath::Pi()) * (deltacp + TMath::Pi()));
  
   // return the log likelihood, ie the log of the normalised sum of the
   // gaussians
   return -std::log(inv_sqrt_2pi * (1 / sigma) * (exp1 + exp2 + exp3)) * (multicanonicalBeta);
 }

◆ GetMulticanonicalWeightVonMises()

double MulticanonicalMCMCHandler::GetMulticanonicalWeightVonMises ( double deltacp ) const

Compute a von Mises multicanonical penalty.

This is the circular analogue of a gaussian, meaning it handles the wrapping of the parameter space at 2pi automatically this avoids the need to calculate the weight multiple times for each parameter to ensure it receives a bias even when it jumps the boundary the normalisation grows extremely quickly, widths of less that 0.05 should not be used until properly tested.

Definition at line 212 of file MulticanonicalMCMCHandler.cpp.

                                                                                       {
   // calculate the Log form of the von Mises instead to avoid numerical issues
   // and return directly
   double log_vonMises = vonMises_kappa * std::cos(deltacp - umbrellaMean) - std::log(2 * TMath::Pi() * vonMises_I0_kappa);
   // return the log likelihood, ie the log of the normalised von Mises
   return -log_vonMises * (multicanonicalBeta);
 }

◆ InitializeMulticanonicalHandlerConfig()

void MulticanonicalMCMCHandler::InitializeMulticanonicalHandlerConfig	(	Manager *	fitMan,
		std::vector< ParameterHandlerBase * > &	systematics
	)

Read multicanonical configuration from the yaml via manager and initialise handler state.

Todo:: DR: I realised this will fail if you set spline to true but don't

Definition at line 71 of file MulticanonicalMCMCHandler.cpp.

                                                                                                                                     {
   const auto mcmcConfig = fitMan->raw()["General"]["MCMC"];
   // need to find param name before calling FindOscCovParams
   multicanonicalVarName = Get<std::string>(mcmcConfig["Multicanonical"]["VariableName"], __FILE__, __LINE__);
   // Set pointers to relevant parameters
   FindOscCovParams(systematics);
  
   // Get the multicanonical beta value from the configuration file
   // This acts as a global bias strength factor
   multicanonicalBeta = Get<double>(mcmcConfig["Multicanonical"]["Beta"],  __FILE__, __LINE__);
   MACH3LOG_INFO("Setting multicanonical beta to {}", multicanonicalBeta);
  
   // delete the umbrella section, thats not ideal
   multicanonicalSpline = GetFromManager<bool>(mcmcConfig["Multicanonical"]["Spline"]["SplineMode"], false, __FILE__, __LINE__);
  
   const std::string biasFunctionName = GetFromManager<std::string>(mcmcConfig["Multicanonical"]["Umbrella"]["UmbrellaBiasFunction"], "", __FILE__, __LINE__);
   const bool hasBiasFunction = !biasFunctionName.empty();
  
   // Spline and umbrella modes are mutually exclusive
   if (multicanonicalSpline && hasBiasFunction) {
     MACH3LOG_ERROR("Cannot use multicanonical spline together with umbrella bias function selection.");
     throw MaCh3Exception(__FILE__, __LINE__, "Cannot use multicanonical spline together with umbrella bias function selection.");
   }
  
   // Umbrella mode requires an explicit bias function selection
   if (!multicanonicalSpline && !hasBiasFunction) {
     MACH3LOG_ERROR("Multicanonical umbrella mode requires UmbrellaBiasFunction to be set (gaussian, vonMises, or generalisedGaussian).");
     throw MaCh3Exception(__FILE__, __LINE__, "Multicanonical umbrella mode requires UmbrellaBiasFunction to be set.");
   }
  
   // Parse and set the umbrella bias function enum
   if (hasBiasFunction) {
     umbrellaBiasFunction = M3::ParseBiasFunction(biasFunctionName);
     umbrellaBiasFunctionName = biasFunctionName;
     MACH3LOG_INFO("Using umbrella bias function {}", umbrellaBiasFunctionName);
   }
  
   // setup for spline bias mode
   if (multicanonicalSpline) {
     auto splineFileName = Get<std::string>(mcmcConfig["Multicanonical"]["Spline"]["SplineFile"], __FILE__, __LINE__);
     TFile* splineFile = M3::Open(splineFileName.c_str(), "READ",__FILE__, __LINE__);
  
     // grab the splines and do a quick check that they are evaluatable
     TSpline3* dcp_spline_IO_fromfile = static_cast<TSpline3*>(splineFile->Get("dcp_spline_IO"));
     dcp_spline_IO = static_cast<TSpline3*>(dcp_spline_IO_fromfile->Clone("dcp_spline_IO"));
     MACH3LOG_INFO("Using multicanonical spline from file {}", splineFileName);
     dcp_spline_IO->Eval(0.0); // check that the spline is valid
     MACH3LOG_INFO("Spline evaluated at 0.0 gives value: {}", dcp_spline_IO->Eval(0.0));
  
     TSpline3* dcp_spline_NO_fromfile = static_cast<TSpline3*>(splineFile->Get("dcp_spline_NO"));
     dcp_spline_NO = static_cast<TSpline3*>(dcp_spline_NO_fromfile->Clone("dcp_spline_NO"));
     MACH3LOG_INFO("Using multicanonical spline from file {}", splineFileName);
     dcp_spline_NO->Eval(0.0); // check that the spline is valid
     MACH3LOG_INFO("Spline evaluated at 0.0 gives value {}", dcp_spline_NO->Eval(0.0));
  
     splineFile->Close();
     splineFile = nullptr;
   } else {
     // Umbrella mode with explicit bias function selection
     MACH3LOG_INFO("Using umbrella multicanonical method with bias function {}", umbrellaBiasFunctionName);
     umbrellaMean = GetFromManager<double>(mcmcConfig["Multicanonical"]["Umbrella"]["UmbrellaMean"], 0, __FILE__, __LINE__);
     MACH3LOG_INFO("Setting multicanonical mean to {}", umbrellaMean);
  
     umbrellaNumber = GetFromManager<int>(mcmcConfig["Multicanonical"]["Umbrella"]["UmbrellaNumber"], 5, __FILE__, __LINE__);
  
     // dynamically adjust the width of the gaussians to ensure a certain level
     // of overlap? be careful, not enough windows here will lead to posterior
     // (rather than bias) dominated results
     umbrellaOverlapMode = GetFromManager<bool>(mcmcConfig["Multicanonical"]["Umbrella"]["AutoOverlapMode"], false, __FILE__, __LINE__);
  
     if (umbrellaOverlapMode) {
       MACH3LOG_INFO("Setting width based on # of sigma overlapping between umbrellas");
       umbrellaSigmaOverlap = GetFromManager<double>(mcmcConfig["Multicanonical"]["Umbrella"]["SigmaOverlap"], 3.0, __FILE__, __LINE__);
       MACH3LOG_INFO("Setting umbrella number to {}", umbrellaNumber);
       umbrellaWidth = TMath::Pi() / ((umbrellaNumber - 1) * (umbrellaSigmaOverlap));
     } else {
       // just grab the width directly from the config
       umbrellaWidth = GetFromManager<double>(mcmcConfig["Multicanonical"]["Umbrella"]["UmbrellaWidth"], (2 * TMath::Pi()) / umbrellaNumber, __FILE__, __LINE__);
       MACH3LOG_INFO("Setting width based on value in config {}", umbrellaWidth);
     }
  
     // set individual step scale for dcp, so that the ratio of the step scale to
     // the multicanonical sigma is stepscale/1sigmaerror = 1/2pi
     umbrellaAdjustStepScale = GetFromManager<bool>(mcmcConfig["Multicanonical"]["Umbrella"]["UmbrellaAdjustStepScale"], false, __FILE__, __LINE__);
     umbrellaStepScaleFactor = GetFromManager<double>(mcmcConfig["Multicanonical"]["Umbrella"]["UmbrellaStepScaleFactor"], 1.0, __FILE__, __LINE__);
  
     AdjustUmbrellaStepScale(systematics);
  
     // Set the flip window flag for the oscillation systematic DO NOT USE THIS
     // flipWindow =
     // GetFromManager<bool>(mcmcConfig["Multicanonical"]["Umbrella"]["FlipWindow"],
     // false, __FILE__, __LINE__); MACH3LOG_INFO("Flip Window: {}", flipWindow);
   }
  
   // initialize von Mises parameters
   if (umbrellaBiasFunction == M3::BiasFunction::kVonMises) {
     double temp_vonMises_sigma;
     temp_vonMises_sigma = GetFromManager<double>(mcmcConfig["Multicanonical"]["Umbrella"]["UmbrellaWidth"], umbrellaWidth, __FILE__, __LINE__);
     vonMises_kappa = 1.0 / (temp_vonMises_sigma * temp_vonMises_sigma);
     vonMises_I0_kappa = TMath::BesselI0(vonMises_kappa);
     MACH3LOG_INFO("Using von Mises distribution with kappa = {} and I0(kappa) = {}", vonMises_kappa, vonMises_I0_kappa);
   }
  
   if (umbrellaBiasFunction == M3::BiasFunction::kGeneralisedGaussian) {
     MACH3LOG_INFO("Using generalised Gaussian with mean {} and width {}", umbrellaMean, umbrellaWidth);
   }
 }

◆ InitializeMulticanonicalParams()

void MulticanonicalMCMCHandler::InitializeMulticanonicalParams ( std::vector< ParameterHandlerBase * > & systematics )

Initialise the starting values used by the multicanonical parameter handling.

This moves the starting point of the chain to the centre of the umbrella bias function. Only affects the parameter of interest.

Definition at line 193 of file MulticanonicalMCMCHandler.cpp.

                                                                                                             {
   // Set starting point of chain to umbrella center for non-spline umbrella modes
   if (!multicanonicalSpline) {
     systematics[oscCovVar]->PrintPreFitCurrPropValues();
     systematics[oscCovVar]->SetParCurrProp(multicanonicalVar, umbrellaMean);
     MACH3LOG_INFO("Setting starting point of chain to mean value for multicanonical separate: {}", umbrellaMean);
     // pass the mean to the covarianceOsc object for parameter flipping DO NOT USE: UNTESTED
     // if (flipWindow) {
     //  auto* oscCov = dynamic_cast<covarianceOsc*>(syst);
     //  if (oscCov) {
     //    oscCov->setFlipWindow(flipWindow);
     //    oscCov->setMulticanonicalSeparateMean(umbrellaMean);
     //  }
     //}
     systematics[oscCovVar]->PrintPreFitCurrPropValues();
     MACH3LOG_INFO("Setting starting point of chain to umbrella center: {}", umbrellaMean);
   }
 }

Member Data Documentation

◆ dcp_spline_IO

TSpline3* MulticanonicalMCMCHandler::dcp_spline_IO

protected

Spline for the IO branch, if spline mode is enabled.

Definition at line 164 of file MulticanonicalMCMCHandler.h.

◆ dcp_spline_NO

TSpline3* MulticanonicalMCMCHandler::dcp_spline_NO

protected

Spline for the NO branch, if spline mode is enabled.

Definition at line 166 of file MulticanonicalMCMCHandler.h.

◆ flipWindow

bool MulticanonicalMCMCHandler::flipWindow

protected

Optional flip-window control.

briefly tested feature to mirror windows about their centres. Not tested but may be useful in the future. Currently disabled and not used.

Definition at line 185 of file MulticanonicalMCMCHandler.h.

◆ multicanonicalBeta

double MulticanonicalMCMCHandler::multicanonicalBeta

protected

Global scale factor applied to the multicanonical penalty. 1 is full strength, 0 is no penalty.

Definition at line 161 of file MulticanonicalMCMCHandler.h.

◆ multicanonicalSpline

bool MulticanonicalMCMCHandler::multicanonicalSpline

Toggle for spline-based multicanonical weights.

Definition at line 157 of file MulticanonicalMCMCHandler.h.

◆ multicanonicalVar

int MulticanonicalMCMCHandler::multicanonicalVar

Parameter index used for the multicanonical weight, most often delta_cp.

Definition at line 141 of file MulticanonicalMCMCHandler.h.

◆ multicanonicalVar_dm23

int MulticanonicalMCMCHandler::multicanonicalVar_dm23

Parameter index used for the multicanonical delm2_23 weight.

Definition at line 143 of file MulticanonicalMCMCHandler.h.

◆ multicanonicalVar_dm23_value

const M3::float_t* MulticanonicalMCMCHandler::multicanonicalVar_dm23_value

Pointer to value of delm2_23 weight used for multicanonical weight.

Definition at line 148 of file MulticanonicalMCMCHandler.h.

◆ multicanonicalVarName

std::string MulticanonicalMCMCHandler::multicanonicalVarName

Parameter name used for the multicanonical weight, most often delta_cp.

Definition at line 139 of file MulticanonicalMCMCHandler.h.

◆ multicanonicalVarValue

const M3::float_t* MulticanonicalMCMCHandler::multicanonicalVarValue

Pointer to value of parameter vale used for multicanonical weight, most often delta_cp.

Definition at line 146 of file MulticanonicalMCMCHandler.h.

◆ oscCovVar

int MulticanonicalMCMCHandler::oscCovVar

Index of the oscillation-covariance systematic in the current fit.

Definition at line 137 of file MulticanonicalMCMCHandler.h.

◆ umbrellaAdjustStepScale

bool MulticanonicalMCMCHandler::umbrellaAdjustStepScale

protected

Toggle for rescaling the step size based on the umbrella width.

Definition at line 180 of file MulticanonicalMCMCHandler.h.

◆ umbrellaBiasFunction

M3::BiasFunction MulticanonicalMCMCHandler::umbrellaBiasFunction

Selected bias function for multicanonical weights.

Definition at line 151 of file MulticanonicalMCMCHandler.h.

◆ umbrellaBiasFunctionName

std::string MulticanonicalMCMCHandler::umbrellaBiasFunctionName

Configured bias function name for logging.

Definition at line 154 of file MulticanonicalMCMCHandler.h.

◆ umbrellaMean

double MulticanonicalMCMCHandler::umbrellaMean

protected

Umbrella centre used for the current configuration.

Definition at line 169 of file MulticanonicalMCMCHandler.h.

◆ umbrellaNumber

int MulticanonicalMCMCHandler::umbrellaNumber

protected

Number of total umbrellas used for the current configuration.

Currently only used when auto-overlap mode is enabled. This is not fully tested.

Definition at line 174 of file MulticanonicalMCMCHandler.h.

◆ umbrellaOverlapMode

bool MulticanonicalMCMCHandler::umbrellaOverlapMode

protected

Toggle for deriving umbrella widths from a desired # of sigma overlaps between umbrellas.

Definition at line 176 of file MulticanonicalMCMCHandler.h.

◆ umbrellaSigmaOverlap

double MulticanonicalMCMCHandler::umbrellaSigmaOverlap

protected

Requested overlap for evenly spaced umbrellas.

Definition at line 178 of file MulticanonicalMCMCHandler.h.

◆ umbrellaStepScaleFactor

double MulticanonicalMCMCHandler::umbrellaStepScaleFactor

protected

Additional scale factor applied when rescaling the step size. This is for fine tuning.

Definition at line 182 of file MulticanonicalMCMCHandler.h.

◆ umbrellaWidth

double MulticanonicalMCMCHandler::umbrellaWidth

protected

Umbrella width used for the current configuration.

Definition at line 171 of file MulticanonicalMCMCHandler.h.

◆ vonMises_I0_kappa

double MulticanonicalMCMCHandler::vonMises_I0_kappa

protected

Cached I0(kappa) value for the von Mises form.

Definition at line 190 of file MulticanonicalMCMCHandler.h.

◆ vonMises_kappa

double MulticanonicalMCMCHandler::vonMises_kappa

protected

Von Mises kappa parameter. Analogue of sigma for a gaussian.

Definition at line 188 of file MulticanonicalMCMCHandler.h.

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

Fitters/Algorithms/MulticanonicalMCMCHandler.h
Fitters/Algorithms/MulticanonicalMCMCHandler.cpp

Public Member Functions

Public Attributes

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MulticanonicalMCMCHandler()

◆ ~MulticanonicalMCMCHandler()

Member Function Documentation

◆ AdjustUmbrellaStepScale()

◆ circularDistance()

◆ FindOscCovParams()

◆ generalisedGaussian2()

◆ GetMulticanonicalWeight()

◆ GetMulticanonicalWeightGaussian()

◆ GetMulticanonicalWeightGenGaussian()

◆ GetMulticanonicalWeightSpline()

◆ GetMulticanonicalWeightTripleGaussian()

◆ GetMulticanonicalWeightVonMises()

◆ InitializeMulticanonicalHandlerConfig()

◆ InitializeMulticanonicalParams()

Member Data Documentation

◆ dcp_spline_IO

◆ dcp_spline_NO

◆ flipWindow

◆ multicanonicalBeta

◆ multicanonicalSpline

◆ multicanonicalVar

◆ multicanonicalVar_dm23

◆ multicanonicalVar_dm23_value

◆ multicanonicalVarName

◆ multicanonicalVarValue

◆ oscCovVar

◆ umbrellaAdjustStepScale

◆ umbrellaBiasFunction

◆ umbrellaBiasFunctionName

◆ umbrellaMean

◆ umbrellaNumber

◆ umbrellaOverlapMode

◆ umbrellaSigmaOverlap

◆ umbrellaStepScaleFactor

◆ umbrellaWidth

◆ vonMises_I0_kappa

◆ vonMises_kappa