M3 Namespace Reference

Typedefs
using	float_t = double
using	int_t = int
using	uint_t = unsigned

Enumerations
enum	kInfCrit { kBIC , kDIC , kWAIC , kInfCrits }
	KS: Different Information Criterion tests mostly based Gelman paper. More...

Functions
template<typename T >
constexpr T	fmaf_t (T x, T y, T z)
	Function template for fused multiply-add.
int	GetNThreads ()
	number of threads which we need for example for TRandom3
int	GetThreadIndex ()
	thread index inside parallel loop
TFile *	Open (const std::string &Name, const std::string &Type, const std::string &File, const int Line)
	Opens a ROOT file with the given name and mode.
template<typename ObjectType >
std::unique_ptr< ObjectType >	Clone (const ObjectType *obj, const std::string &name="")
	KS: Creates a copy of a ROOT-like object and wraps it in a smart pointer.
double *	MatrixMult (double *A, double *B, int n)
	CW: Multi-threaded matrix multiplication.
double **	MatrixMult (double **A, double **B, int n)
	CW: Multi-threaded matrix multiplication.
TMatrixD	MatrixMult (TMatrixD A, TMatrixD B)
	CW: Multi-threaded matrix multiplication.
void	MatrixVectorMulti (double *_restrict_ VecMulti, double **_restrict_ matrix, const double *_restrict_ vector, const int n)
	KS: Custom function to perform multiplication of matrix and vector with multithreading.
double	MatrixVectorMultiSingle (double **_restrict_ matrix, const double *_restrict_ vector, const int Length, const int i)
	KS: Custom function to perform multiplication of matrix and single element which is thread safe.
void	FixSampleNamesQuotes (std::string &yamlStr)
	KS: Yaml emitter has problem and drops "", if you have special signs in you like * then there is problem. This bit hacky code adds these "".
void	AddTuneValues (YAML::Node &root, const std::vector< double > &Values, const std::string &Tune, const std::vector< std::string > &FancyNames={})
	KS: Add Tune values to YAML covariance matrix.
void	MakeCorrelationMatrix (YAML::Node &root, const std::vector< double > &Values, const std::vector< double > &Errors, const std::vector< std::vector< double > > &Correlation, const std::vector< std::string > &FancyNames={})
	KS: Replace correlation matrix and tune values in YAML covariance matrix.
TMacro *	GetConfigMacroFromChain (TDirectory *CovarianceFolder)
	KS: We store configuration macros inside the chain. In the past, multiple configs were stored, which required error-prone hardcoding like "Config_xsec_cov". Therefore, this code maintains backward compatibility by checking the number of macros present and using a hardcoded name only if necessary.
TMatrixDSym *	GetCovMatrixFromChain (TDirectory *TempFile)
	KS: Retrieve the cross-section covariance matrix from the given TDirectory. Historically, multiple covariance matrices could be stored, requiring fragile hardcoded paths like "CovarianceFolder/xsec_cov". This function maintains backward compatibility by:

Variables
static constexpr const double	_BAD_DOUBLE_ = -999.99
	Default value used for double initialisation.
static constexpr const int	_BAD_INT_ = -999
	Default value used for int initialisation.
static constexpr const double	_DEFAULT_RETURN_VAL_ = -999999.123456
static constexpr const double	Unity_D = 1.
	Some commonly used variables to which we set pointers to.
static constexpr const float	Unity_F = 1.
static constexpr const float_t	Unity = Unity_D
static constexpr const double	Zero_D = 0.
static constexpr const float	Zero_F = 0.
static constexpr const float_t	Zero = Zero_D
static constexpr const double	KinematicLowBound = std::numeric_limits<double>::lowest()
	When parameter has no bound this serves as it. Lowest possible value the system.
static constexpr const double	KinematicUpBound = std::numeric_limits<double>::max()
	When parameter has no bound this serves as it. Highest possible value the system.
static constexpr const double	_LARGE_LOGL_ = 1234567890.0
	Large Likelihood is used it parameter go out of physical boundary, this indicates in MCMC that such step should be removed.
static constexpr const double	_LOW_MC_BOUND_ = .00001
	MC prediction lower bound in bin to identify problematic binning definitions and handle LogL calculation.
static constexpr const double	DefSplineKnotUpBound = 9999
	Default value for spline knot capping, default mean not capping is being applied.
static constexpr const double	DefSplineKnotLowBound = -9999
	Default value for spline knot capping, default mean not capping is being applied.

Detailed Description

Run low or high memory versions of structs N.B. for 64 bit systems sizeof(float) == sizeof(double) so not a huge effect

Typedef Documentation

float_t

using M3::float_t = typedef double

Definition at line 28 of file Core.h.

int_t

using M3::int_t = typedef int

Definition at line 29 of file Core.h.

uint_t

using M3::uint_t = typedef unsigned

Definition at line 30 of file Core.h.

Enumeration Type Documentation

kInfCrit

enum M3::kInfCrit

KS: Different Information Criterion tests mostly based Gelman paper.

Enumerator
kBIC	Bayesian Information Criterion.
kDIC	Deviance Information Criterion.
kWAIC	Watanabe-Akaike information criterion.
kInfCrits	This only enumerates.

Definition at line 10 of file SampleSummary.h.

                {
    kBIC,      
    kDIC,      
    kWAIC,     
    kInfCrits  
  };

Function Documentation

AddTuneValues()

void M3::AddTuneValues ( YAML::Node &  root, const std::vector< double > &  Values, const std::string &  Tune, const std::vector< std::string > &  FancyNames = {}  )

inline

KS: Add Tune values to YAML covariance matrix.

Definition at line 181 of file ParameterHandlerUtils.h.

                                                                   {}) {
// *************************************
  YAML::Node NodeCopy = YAML::Clone(root);
  YAML::Node systematics = NodeCopy["Systematics"];
 
  if (!systematics || !systematics.IsSequence()) {
    MACH3LOG_ERROR("'Systematics' node is missing or not a sequence in the YAML copy");
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  if (!FancyNames.empty() && FancyNames.size() != Values.size()) {
    MACH3LOG_ERROR("Mismatch in sizes: FancyNames has {}, but Values has {}", FancyNames.size(), Values.size());
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  if (FancyNames.empty() && systematics.size() != Values.size()) {
    MACH3LOG_ERROR("Mismatch in sizes: Values has {}, but YAML 'Systematics' has {} entries",
                   Values.size(), systematics.size());
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  if (!FancyNames.empty()) {
    for (std::size_t i = 0; i < FancyNames.size(); ++i) {
      bool matched = false;
      for (std::size_t j = 0; j < systematics.size(); ++j) {
        YAML::Node systematicNode = systematics[j]["Systematic"];
        if (!systematicNode) continue;
        auto nameNode = systematicNode["Names"];
        if (!nameNode || !nameNode["FancyName"]) continue;
        if (nameNode["FancyName"].as<std::string>() == FancyNames[i]) {
          if (!systematicNode["ParameterValues"]) {
            MACH3LOG_ERROR("Missing 'ParameterValues' for matched FancyName '{}'", FancyNames[i]);
            throw MaCh3Exception(__FILE__, __LINE__);
          }
          systematicNode["ParameterValues"][Tune] = MaCh3Utils::FormatDouble(Values[i], 4);
          matched = true;
          break;
        }
      }
      if (!matched) {
        MACH3LOG_ERROR("Could not find a matching FancyName '{}' in the systematics", FancyNames[i]);
        throw MaCh3Exception(__FILE__, __LINE__);
      }
    }
  } else {
    for (std::size_t i = 0; i < systematics.size(); ++i) {
      YAML::Node systematicNode = systematics[i]["Systematic"];
      if (!systematicNode || !systematicNode["ParameterValues"]) {
        MACH3LOG_ERROR("Missing 'Systematic' or 'ParameterValues' entry at index {}", i);
        throw MaCh3Exception(__FILE__, __LINE__);
      }
      systematicNode["ParameterValues"][Tune] = MaCh3Utils::FormatDouble(Values[i], 4);
    }
  }
 
  // Convert updated copy to string
  std::string YAMLString = YAMLtoSTRING(NodeCopy);
  FixSampleNamesQuotes(YAMLString);
  // Write to output file
  std::string OutName = "UpdatedMatrixWithTune" + Tune + ".yaml";
  std::ofstream outFile(OutName);
  if (!outFile) {
    MACH3LOG_ERROR("Failed to open file for writing: {}", OutName);
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  outFile << YAMLString;
  outFile.close();
}

Clone()

template<typename ObjectType >

std::unique_ptr< ObjectType > M3::Clone	(	const ObjectType *	obj,
		const std::string &	name = ""
	)

KS: Creates a copy of a ROOT-like object and wraps it in a smart pointer.

Template Parameters

ObjectType

The type of the object to clone for example TH1D or TH2Poly.

Parameters

obj	Pointer to the object to clone.

Returns

std::unique_ptr<ObjectType> Owning pointer to the cloned object.

Definition at line 138 of file HistogramUtils.h.

                                                                                   {
  std::string cloneName = name.empty() ? obj->GetName() : name;
 
  std::unique_ptr<ObjectType> Hist(static_cast<ObjectType*>(obj->Clone(cloneName.c_str())));
  // Disable ROOT memory management because it causes lot of headache especially as smart pointers are much smarter
  Hist->SetDirectory(nullptr);
 
  return Hist;
}

FixSampleNamesQuotes()

void M3::FixSampleNamesQuotes ( std::string &  yamlStr )

inline

KS: Yaml emitter has problem and drops "", if you have special signs in you like * then there is problem. This bit hacky code adds these "".

Definition at line 150 of file ParameterHandlerUtils.h.

                                                     {
// *************************************
  std::stringstream input(yamlStr);
  std::string line;
  std::string fixedYaml;
  std::regex sampleNamesRegex(R"(SampleNames:\s*\[([^\]]+)\])");
 
  while (std::getline(input, line)) {
    std::smatch match;
    if (std::regex_search(line, match, sampleNamesRegex)) {
      std::string contents = match[1];  // inside the brackets
      std::stringstream ss(contents);
      std::string item;
      std::vector<std::string> quotedItems;
 
      while (std::getline(ss, item, ',')) {
        item = std::regex_replace(item, std::regex(R"(^\s+|\s+$)"), ""); // trim
        quotedItems.push_back("\"" + item + "\"");
      }
 
      std::string replacement = "SampleNames: [" + fmt::format("{}", fmt::join(quotedItems, ", ")) + "]";
      line = std::regex_replace(line, sampleNamesRegex, replacement);
    }
    fixedYaml += line + "\n";
  }
 
  yamlStr = fixedYaml;
}

fmaf_t()

template<typename T >

constexpr T M3::fmaf_t ( T  x, T  y, T  z  )

constexpr

Function template for fused multiply-add.

Definition at line 35 of file Core.h.

                                    {
    #ifdef _LOW_MEMORY_STRUCTS_
    return std::fmaf(x, y, z);
    #else
    return std::fma(x, y, z);
    #endif
  }

GetConfigMacroFromChain()

TMacro * M3::GetConfigMacroFromChain ( TDirectory *  CovarianceFolder )

inline

KS: We store configuration macros inside the chain. In the past, multiple configs were stored, which required error-prone hardcoding like "Config_xsec_cov". Therefore, this code maintains backward compatibility by checking the number of macros present and using a hardcoded name only if necessary.

Definition at line 366 of file ParameterHandlerUtils.h.

                                                                     {
// *************************************
  if (!CovarianceFolder) {
    MACH3LOG_ERROR("Null TDirectory passed to {}", __func__);
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  TMacro* foundMacro = nullptr;
  int macroCount = 0;
 
  TIter next(CovarianceFolder->GetListOfKeys());
  TKey* key;
  while ((key = dynamic_cast<TKey*>(next()))) {
    if (std::string(key->GetClassName()) == "TMacro") {
      ++macroCount;
      if (macroCount == 1) {
        foundMacro = dynamic_cast<TMacro*>(key->ReadObj());
      }
    }
  }
 
  if (macroCount == 1 && foundMacro) {
    MACH3LOG_INFO("Found single TMacro in directory: using it.");
    return foundMacro;
  } else {
    MACH3LOG_WARN("Found {} TMacro objects. Using hardcoded macro name: Config_xsec_cov.", macroCount);
    TMacro* fallback = CovarianceFolder->Get<TMacro>("Config_xsec_cov");
    if (!fallback) {
      MACH3LOG_WARN("Fallback macro 'Config_xsec_cov' not found in directory.");
    }
    return fallback;
  }
}

GetCovMatrixFromChain()

TMatrixDSym * M3::GetCovMatrixFromChain ( TDirectory *  TempFile )

inline

KS: Retrieve the cross-section covariance matrix from the given TDirectory. Historically, multiple covariance matrices could be stored, requiring fragile hardcoded paths like "CovarianceFolder/xsec_cov". This function maintains backward compatibility by:

• Using the single matrix present if only one exists,
• Otherwise falling back to the hardcoded path. This avoids error-prone assumptions while supporting both old and new formats.

Definition at line 407 of file ParameterHandlerUtils.h.

                                                                {
// *************************************
  if (!TempFile) {
    MACH3LOG_ERROR("Null TDirectory passed to {}.", __func__);
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  TMatrixDSym* foundMatrix = nullptr;
  int matrixCount = 0;
 
  TIter next(TempFile->GetListOfKeys());
  TKey* key;
  while ((key = dynamic_cast<TKey*>(next()))) {
    std::string className = key->GetClassName();
    if (className.find("TMatrix") != std::string::npos) {
      ++matrixCount;
      if (matrixCount == 1) {
        foundMatrix = dynamic_cast<TMatrixDSym*>(key->ReadObj());
      }
    }
  }
 
  if (matrixCount == 1 && foundMatrix) {
    MACH3LOG_INFO("Found single TMatrixDSym in directory: using it.");
    return foundMatrix;
  } else {
    MACH3LOG_WARN("Found {} TMatrixDSym objects. Using hardcoded path: xsec_cov.", matrixCount);
    TMatrixDSym* fallback = TempFile->Get<TMatrixDSym>("xsec_cov");
    if (!fallback) {
      MACH3LOG_WARN("Fallback matrix 'xsec_cov' not found.");
    }
    return fallback;
  }
}

GetNThreads()

int M3::GetNThreads

(

)

number of threads which we need for example for TRandom3

Definition at line 322 of file Monitor.cpp.

                  {
// ***************************************************************************
  #ifdef MULTITHREAD
  return omp_get_max_threads();
  #else
  return 1;
  #endif
}

GetThreadIndex()

int M3::GetThreadIndex ( )

inline

thread index inside parallel loop

Definition at line 82 of file Monitor.h.

                              {
    #ifdef MULTITHREAD
    return omp_get_thread_num();
    #else
    return 0;
    #endif
  }

MakeCorrelationMatrix()

void M3::MakeCorrelationMatrix ( YAML::Node &  root, const std::vector< double > &  Values, const std::vector< double > &  Errors, const std::vector< std::vector< double > > &  Correlation, const std::vector< std::string > &  FancyNames = {}  )

inline

KS: Replace correlation matrix and tune values in YAML covariance matrix.

Definition at line 256 of file ParameterHandlerUtils.h.

                                                                           {}) {
// *************************************
  if (Values.size() != Errors.size() || Values.size() != Correlation.size()) {
    MACH3LOG_ERROR("Size mismatch between Values, Errors, and Correlation matrix");
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  for (const auto& row : Correlation) {
    if (row.size() != Correlation.size()) {
      MACH3LOG_ERROR("Correlation matrix is not square");
      throw MaCh3Exception(__FILE__, __LINE__);
    }
  }
 
  YAML::Node NodeCopy = YAML::Clone(root);
  YAML::Node systematics = NodeCopy["Systematics"];
 
  if (!systematics || !systematics.IsSequence()) {
    MACH3LOG_ERROR("'Systematics' node is missing or not a sequence");
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  if (!FancyNames.empty() && FancyNames.size() != Values.size()) {
    MACH3LOG_ERROR("FancyNames size ({}) does not match Values size ({})", FancyNames.size(), Values.size());
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  // Map from FancyName to Systematic node
  std::unordered_map<std::string, YAML::Node> nameToNode;
  for (std::size_t i = 0; i < systematics.size(); ++i) {
    YAML::Node syst = systematics[i]["Systematic"];
    if (!syst || !syst["Names"] || !syst["Names"]["FancyName"]) continue;
    std::string name = syst["Names"]["FancyName"].as<std::string>();
    nameToNode[name] = syst;
  }
 
  if (!FancyNames.empty()) {
    for (std::size_t i = 0; i < FancyNames.size(); ++i) {
      const std::string& name_i = FancyNames[i];
      auto it_i = nameToNode.find(name_i);
      if (it_i == nameToNode.end()) {
        MACH3LOG_ERROR("Could not find FancyName '{}' in YAML", name_i);
        throw MaCh3Exception(__FILE__, __LINE__);
      }
      YAML::Node& syst_i = it_i->second;
 
      syst_i["ParameterValues"]["PreFitValue"] = MaCh3Utils::FormatDouble(Values[i], 4);
      syst_i["Error"] = std::round(Errors[i] * 100.0) / 100.0;
 
      YAML::Node correlationsNode = YAML::Node(YAML::NodeType::Sequence);
      for (std::size_t j = 0; j < FancyNames.size(); ++j) {
        if (i == j) continue;
        YAML::Node singleEntry;
        singleEntry[FancyNames[j]] = MaCh3Utils::FormatDouble(Correlation[i][j], 4);
        correlationsNode.push_back(singleEntry);
      }
      syst_i["Correlations"] = correlationsNode;
    }
  } else {
    if (systematics.size() != Values.size()) {
      MACH3LOG_ERROR("Mismatch in sizes: Values has {}, but YAML 'Systematics' has {} entries",
                     Values.size(), systematics.size());
      throw MaCh3Exception(__FILE__, __LINE__);
    }
 
    for (std::size_t i = 0; i < systematics.size(); ++i) {
      YAML::Node syst = systematics[i]["Systematic"];
      if (!syst) {
        MACH3LOG_ERROR("Missing 'Systematic' node at index {}", i);
        throw MaCh3Exception(__FILE__, __LINE__);
      }
 
      syst["ParameterValues"]["PreFitValue"] = MaCh3Utils::FormatDouble(Values[i], 4);
      syst["Error"] = std::round(Errors[i] * 100.0) / 100.0;
 
      YAML::Node correlationsNode = YAML::Node(YAML::NodeType::Sequence);
      for (std::size_t j = 0; j < Correlation[i].size(); ++j) {
        if (i == j) continue;
        YAML::Node singleEntry;
        const std::string& otherName = systematics[j]["Systematic"]["Names"]["FancyName"].as<std::string>();
        singleEntry[otherName] = MaCh3Utils::FormatDouble(Correlation[i][j], 4);
        correlationsNode.push_back(singleEntry);
      }
      syst["Correlations"] = correlationsNode;
    }
  }
 
  // Convert and write
  std::string YAMLString = YAMLtoSTRING(NodeCopy);
  FixSampleNamesQuotes(YAMLString);
  std::string OutName = "UpdatedCorrelationMatrix.yaml";
  std::ofstream outFile(OutName);
  if (!outFile) {
    MACH3LOG_ERROR("Failed to open file for writing: {}", OutName);
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  outFile << YAMLString;
  outFile.close();
}

MatrixMult() [1/3]

double ** M3::MatrixMult ( double **  A, double **  B, int  n  )

inline

CW: Multi-threaded matrix multiplication.

Definition at line 62 of file ParameterHandlerUtils.h.

                                                          {
  // First make into monolithic array
  double *A_mon = new double[n*n];
  double *B_mon = new double[n*n];
 
  #ifdef MULTITHREAD
  #pragma omp parallel for
  #endif
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      A_mon[i*n+j] = A[i][j];
      B_mon[i*n+j] = B[i][j];
    }
  }
  //CW: Now call the monolithic calculator
  double *C_mon = MatrixMult(A_mon, B_mon, n);
  delete A_mon;
  delete B_mon;
 
  // Return the double pointer
  double **C = new double*[n];
  #ifdef MULTITHREAD
  #pragma omp parallel for
  #endif
  for (int i = 0; i < n; ++i) {
    C[i] = new double[n];
    for (int j = 0; j < n; ++j) {
      C[i][j] = C_mon[i*n+j];
    }
  }
  delete C_mon;
 
  return C;
}

MatrixMult() [2/3]

double * M3::MatrixMult ( double *  A, double *  B, int  n  )

inline

CW: Multi-threaded matrix multiplication.

Definition at line 30 of file ParameterHandlerUtils.h.

                                                       {
  //CW: First transpose to increse cache hits
  double *BT = new double[n*n];
  #ifdef MULTITHREAD
  #pragma omp parallel for
  #endif
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      BT[j*n+i] = B[i*n+j];
    }
  }
 
  // Now multiply
  double *C = new double[n*n];
  #ifdef MULTITHREAD
  #pragma omp parallel for
  #endif
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      double sum = 0;
      for (int k = 0; k < n; k++) {
        sum += A[i*n+k]*BT[j*n+k];
      }
      C[i*n+j] = sum;
    }
  }
  delete BT;
 
  return C;
}

MatrixMult() [3/3]

TMatrixD M3::MatrixMult ( TMatrixD  A, TMatrixD  B  )

inline

CW: Multi-threaded matrix multiplication.

Definition at line 98 of file ParameterHandlerUtils.h.

{
  double *C_mon = MatrixMult(A.GetMatrixArray(), B.GetMatrixArray(), A.GetNcols());
  TMatrixD C;
  C.Use(A.GetNcols(), A.GetNrows(), C_mon);
  return C;
}

MatrixVectorMulti()

void M3::MatrixVectorMulti ( double *_restrict_  VecMulti, double **_restrict_  matrix, const double *_restrict_  vector, const int  n  )

inline

KS: Custom function to perform multiplication of matrix and vector with multithreading.

Parameters

VecMulti	Output Vector, VecMulti = matrix x vector
matrix	This matrix is used for multiplication VecMulti = matrix x vector
VecMulti	This vector is used for multiplication VecMulti = matrix x vector
n	this is size of matrix and vector, we assume matrix is symmetric

Definition at line 112 of file ParameterHandlerUtils.h.

                                                                                                                                     {
// ********************************************
  #ifdef MULTITHREAD
  #pragma omp parallel for
  #endif
  for (int i = 0; i < n; ++i)
  {
    double result = 0.0;
    #ifdef MULTITHREAD
    #pragma omp simd
    #endif
    for (int j = 0; j < n; ++j)
    {
      result += matrix[i][j]*vector[j];
    }
    VecMulti[i] = result;
  }
}

MatrixVectorMultiSingle()

double M3::MatrixVectorMultiSingle ( double **_restrict_  matrix, const double *_restrict_  vector, const int  Length, const int  i  )

inline

KS: Custom function to perform multiplication of matrix and single element which is thread safe.

Parameters

matrix	This matrix is used for multiplication VecMulti = matrix x vector
Length	this is size of matrix and vector, we assume matrix is symmetric
i	Element of matrix that we want to multiply

Definition at line 136 of file ParameterHandlerUtils.h.

                                                                                                                                  {
// ********************************************
  double Element = 0.0;
  #ifdef MULTITHREAD
  #pragma omp simd
  #endif
  for (int j = 0; j < Length; ++j) {
    Element += matrix[i][j]*vector[j];
  }
  return Element;
}

Open()

TFile * M3::Open	(	const std::string &	Name,
		const std::string &	Type,
		const std::string &	File,
		const int	Line
	)

Opens a ROOT file with the given name and mode.

This function wraps ROOT’s TFile constructor and checks whether the file was opened successfully and give some useful debugging information

Parameters

Name	The name or path of the file to open.
Type	The file open mode (e.g., "READ", "RECREATE", "UPDATE").

Returns

Pointer to the opened ROOT file.

Definition at line 610 of file HistogramUtils.cpp.

                                                                                                 {
// **************************************************************************
  TFile* OutFile = new TFile(Name.c_str(), Type.c_str());
 
  // Check if the file is successfully opened and usable
  if (OutFile->IsZombie()) {
    MACH3LOG_ERROR("Failed to open file: {}", Name);
    if (Type == "RECREATE") {
      MACH3LOG_ERROR("Check if directory exist");
    }
    delete OutFile;
    throw MaCh3Exception(File, Line);
  }
  return OutFile;
}

Variable Documentation

_BAD_DOUBLE_

constexpr const double M3::_BAD_DOUBLE_ = -999.99

staticconstexpr

Default value used for double initialisation.

Definition at line 43 of file Core.h.

_BAD_INT_

constexpr const int M3::_BAD_INT_ = -999

staticconstexpr

Default value used for int initialisation.

Definition at line 45 of file Core.h.

_DEFAULT_RETURN_VAL_

constexpr const double M3::_DEFAULT_RETURN_VAL_ = -999999.123456

staticconstexpr

Definition at line 46 of file Core.h.

_LARGE_LOGL_

constexpr const double M3::_LARGE_LOGL_ = 1234567890.0

staticconstexpr

Large Likelihood is used it parameter go out of physical boundary, this indicates in MCMC that such step should be removed.

Definition at line 70 of file Core.h.

_LOW_MC_BOUND_

constexpr const double M3::_LOW_MC_BOUND_ = .00001

staticconstexpr

MC prediction lower bound in bin to identify problematic binning definitions and handle LogL calculation.

Definition at line 73 of file Core.h.

DefSplineKnotLowBound

constexpr const double M3::DefSplineKnotLowBound = -9999

staticconstexpr

Default value for spline knot capping, default mean not capping is being applied.

Definition at line 78 of file Core.h.

DefSplineKnotUpBound

constexpr const double M3::DefSplineKnotUpBound = 9999

staticconstexpr

Default value for spline knot capping, default mean not capping is being applied.

Definition at line 76 of file Core.h.

KinematicLowBound

constexpr const double M3::KinematicLowBound = std::numeric_limits<double>::lowest()

staticconstexpr

When parameter has no bound this serves as it. Lowest possible value the system.

Definition at line 65 of file Core.h.

KinematicUpBound

constexpr const double M3::KinematicUpBound = std::numeric_limits<double>::max()

staticconstexpr

When parameter has no bound this serves as it. Highest possible value the system.

Definition at line 67 of file Core.h.

Unity

constexpr const float_t M3::Unity = Unity_D

staticconstexpr

Definition at line 54 of file Core.h.

Unity_D

constexpr const double M3::Unity_D = 1.

staticconstexpr

Some commonly used variables to which we set pointers to.

Definition at line 49 of file Core.h.

Unity_F

constexpr const float M3::Unity_F = 1.

staticconstexpr

Definition at line 50 of file Core.h.

Zero

constexpr const float_t M3::Zero = Zero_D

staticconstexpr

Definition at line 61 of file Core.h.

Zero_D

constexpr const double M3::Zero_D = 0.

staticconstexpr

Definition at line 56 of file Core.h.

Zero_F

constexpr const float M3::Zero_F = 0.

staticconstexpr

Definition at line 57 of file Core.h.