MaCh3Factory.h File Reference

Factory methods for MaCh3 software which streamline initialisation of different objects. More...

#include "Fitters/FitterBase.h"
#include "Fitters/MR2T2.h"
#include "Fitters/DelayedMR2T2.h"
#include "Fitters/PSO.h"
#include "Fitters/LikelihoodFit.h"
#include "Parameters/ParameterHandlerGeneric.h"

Include dependency graph for MaCh3Factory.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
std::unique_ptr< FitterBase >	MaCh3FitterFactory (Manager *FitManager)
	MaCh3 Factory initiates one of implemented fitting algorithms. More...
std::unique_ptr< Manager >	MaCh3ManagerFactory (int argc, char **argv)
	Initializes the config Manager class and allows overriding settings via command-line arguments. More...
template<typename CovType >
std::unique_ptr< CovType >	MaCh3CovarianceFactory (Manager *FitManager, const std::string &PreFix)
	Factory function for creating a covariance class for systematic handling. More...
template<typename SampleType >
std::vector< SampleType * >	MaCh3SampleHandlerFactory (const std::vector< std::string > &SampleConfig, ParameterHandlerGeneric *xsec)
	Factory function for creating SampleHandler and initialisation with systematic. More...

Detailed Description

Factory methods for MaCh3 software which streamline initialisation of different objects.

Author

Kamil Skwarczynski

Definition in file MaCh3Factory.h.

Function Documentation

MaCh3CovarianceFactory()

template<typename CovType >

std::unique_ptr<CovType> MaCh3CovarianceFactory	(	Manager *	FitManager,
		const std::string &	PreFix
	)

Factory function for creating a covariance class for systematic handling.

Parameters

FitManager	Pointer to the Manager class that holds the configuration settings.
PreFix	Prefix, for example Xsec, then code will look for XsecCovFile

Returns

Pointer to the initialized covarianceXsec matrix object.

Note

Example YAML configuration:

MaCh3CovarianceFactory(, Xsec)
 
 General:
   Systematics:
       XsecCovName: "xsec_cov"
       XsecCovFile: ["inputs/blarb1.yaml",
                     "inputs/blarb2.yaml"]
       XsecFix: ["Param_0",
                 "Param_1"]
       XsecPCAThreshold: -1
       #XsecPCAThreshold: 0.00001
 
       XsecPCAParams: [-999, -999]
       XsecStepScale: 0.0075

Todo:

add adaptive stuff

Definition at line 70 of file MaCh3Factory.h.

                                                                                            {
// ********************************************
  // config for our matrix
  YAML::Node Settings = FitManager->raw()["General"]["Systematics"];
  auto CovMatrixName = Get<std::string>(Settings[std::string(PreFix) + "CovName"], __FILE__, __LINE__);
  MACH3LOG_INFO("Initialising {} matrix", CovMatrixName);
 
  // yaml files initialising out matrix
  auto CovMatrixFile = Get<std::vector<std::string>>(Settings[std::string(PreFix) + "CovFile"], __FILE__, __LINE__);
 
  // PCA threshold, -1 means no pca
  auto PCAThreshold = GetFromManager<int>(Settings[std::string(PreFix) + "PCAThreshold"], -1);
  // do we pca whole matrix or only submatrix
  auto PCAParamRegion = GetFromManager<std::vector<int>>(Settings[std::string(PreFix) + "PCAParams"], {-999, -999});
 
  auto CovObject = std::make_unique<CovType>(CovMatrixFile, CovMatrixName, PCAThreshold, PCAParamRegion[0], PCAParamRegion[1]);
 
  // Fill the parameter values with their nominal values
  // should _ALWAYS_ be done before overriding with fix or flat
  CovObject->SetParameters();
 
  auto FixParams = GetFromManager<std::vector<std::string>>(Settings[std::string(PreFix) + "Fix"], {});
 
  // Fixed CovObject parameters loop
  if (FixParams.size() == 1 && FixParams.at(0) == "All") {
    for (int j = 0; j < CovObject->GetNumParams(); j++) {
      CovObject->ToggleFixParameter(j);
    }
  } else {
    for (unsigned int j = 0; j < FixParams.size(); j++) {
      CovObject->ToggleFixParameter(FixParams.at(j));
    }
  }
 
  if (CheckNodeExists(Settings, std::string(PreFix) + "Tune"))
  {
    CovObject->SetTune(Get<std::string>(Settings[std::string(PreFix) + "Tune"], __FILE__, __LINE__));
  }
 
  //Global step scale for matrix
  auto StepScale = Get<double>(Settings[std::string(PreFix) + "StepScale"], __FILE__, __LINE__);
 
  CovObject->SetStepScale(StepScale);
 
  // Adaptive MCMC stuff
  if (CheckNodeExists(FitManager->raw(), "AdaptionOptions")) {
    CovObject->InitialiseAdaption(FitManager->raw());
  }
  
  return CovObject;
}

MaCh3ManagerFactory()

std::unique_ptr<Manager> MaCh3ManagerFactory	(	int	argc,
		char **	argv
	)

Initializes the config Manager class and allows overriding settings via command-line arguments.

Parameters

argc	number of arguments
argv	name of arguments

Returns

A unique pointer to the initialized Manager instance with optional overrides applied.

Note

Usage examples:

./bin/MCMCTutorial Inputs/FitterConfig.yaml General:OutputFile:blarb.root
./bin/MCMCTutorial Inputs/FitterConfig.yaml General:OutputFile:blarb.root General:MCMC:NSteps:50000

Todo:

KS: May need some recursive magic to reduce amount of hardcoding

Definition at line 41 of file MaCh3Factory.cpp.

                                                                  {
// ********************************************
  if (argc < 2) {
    MACH3LOG_ERROR("Wrong usage of MaCh3 executable!");
    MACH3LOG_ERROR("Syntax is $: {} config.yaml", argv[0]);
    MACH3LOG_ERROR("Where config.yaml is a valid config file, compatible with the Manager class (Manager/Manager.cpp/h)");
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  // Check if we are using --override mode
  if (argc >= 4 && std::string(argv[2]) == "--override") {
    const std::string overrideFile = argv[3];
      MACH3LOG_INFO("Merging configuration files: base config '{}', override config '{}'. "
                "Options in '{}' will take precedence over '{}'.",
                argv[1], overrideFile, overrideFile, argv[1]);
 
    if(argc > 4) {
      MACH3LOG_ERROR("Too many arguments provided when using '--override'. "
                   "Expected only two config files. "
                   "If using override feature, you cannot provide any additional arguments.");
      throw MaCh3Exception(__FILE__, __LINE__);
    }
    // Load the two YAML files
    YAML::Node config1 = M3OpenConfig(argv[1]);
    YAML::Node config2 = M3OpenConfig(overrideFile);
 
    // Merge them
    YAML::Node merged = MergeNodes(config1, config2);
    auto FitManager = std::make_unique<Manager>(merged);
 
    return FitManager;
  }
 
  // Initialise manger responsible for config handling
  auto FitManager = std::make_unique<Manager>(argv[1]);
  
  //KS: Lambda to make sure we are not overwriting setting which should be committed
  auto SanityOverwrite = [](const std::string& Name) {
    if (Name.find("Systematics") != std::string::npos ||
        Name.find("Samples") != std::string::npos)
    {
      MACH3LOG_CRITICAL("You are overwriting settings ({}) that are highly likely intended to be committed.", Name);
      throw MaCh3Exception(__FILE__ , __LINE__ );
    }
  };
  
  for (int i = 2; i < argc; ++i)
  {
    const std::string arg = argv[i];
    const size_t colonCount = std::count(arg.begin(), arg.end(), ':');
 
    if (colonCount == 1) {
      const size_t firstColon = arg.find(':');
      const std::string section = arg.substr(0, firstColon);
      const std::string value = arg.substr(firstColon + 1);
 
      MACH3LOG_INFO("Overriding setting: Section={}, Value={}", section, value);
      SanityOverwrite(section);
      FitManager->OverrideSettings(section, value);
    } else if (colonCount == 2) {
      const size_t firstColon = arg.find(':');
      const size_t secondColon = arg.find(':', firstColon + 1);
 
      const std::string section = arg.substr(0, firstColon);
      const std::string key = arg.substr(firstColon + 1, secondColon - firstColon - 1);
      const std::string value = arg.substr(secondColon + 1);
 
      MACH3LOG_INFO("Overriding setting: Section={}, Key={}, Value={}", section, key, value);
      SanityOverwrite(section);
      SanityOverwrite(key);
      FitManager->OverrideSettings(section, key, value);
    } else if (colonCount == 3) {
      const size_t firstColon = arg.find(':');
      const size_t secondColon = arg.find(':', firstColon + 1);
      const size_t thridColon = arg.find(':', secondColon + 1);
 
      const std::string section = arg.substr(0, firstColon);
      const std::string key = arg.substr(firstColon + 1, secondColon - firstColon - 1);
      const std::string key2 = arg.substr(secondColon + 1, thridColon - secondColon - 1);
      const std::string value = arg.substr(thridColon + 1);
 
      MACH3LOG_INFO("Overriding setting: Section={}, Key={}, Key={}, Value={}", section, key, key2, value);
      SanityOverwrite(section);
      SanityOverwrite(key);
      SanityOverwrite(key2);
      FitManager->OverrideSettings(section, key, key2, value);
    } else {
      MACH3LOG_ERROR("Invalid override argument format: {}", arg);
      MACH3LOG_ERROR("Expected format:Section:Key:Key:Value, Section:Key:Value or Section:Value");
      throw MaCh3Exception(__FILE__, __LINE__);
    }
  }
  return FitManager;
}

MaCh3SampleHandlerFactory()

template<typename SampleType >

std::vector<SampleType*> MaCh3SampleHandlerFactory	(	const std::vector< std::string > &	SampleConfig,
		ParameterHandlerGeneric *	xsec
	)

Factory function for creating SampleHandler and initialisation with systematic.

Template Parameters

SampleType

The class type of the sample to create, e.g., SampleHandlerTutorial.

Parameters

SampleConfig	Path to sample config.
xsec	A pointer to a ParameterHandlerGeneric object for cross-section systematic settings.

Returns

Vector of SampleType object, initialized and ready for use.

Note

Example

auto mySamples = MaCh3SampleHandlerFactory<SampleHandlerTutorial>(SampleConfig, xsec);

Definition at line 135 of file MaCh3Factory.h.

                                                                              {
// ********************************************
  std::vector<SampleType*> Handlers(SampleConfig.size());
  for (size_t i = 0; i < SampleConfig.size(); ++i)
  {
    // Instantiate the sample using the specified class type
    SampleType* Sample = new SampleType(SampleConfig[i], xsec);
    Sample->Reweight();
 
    for(int iSample = 0; iSample < Sample->GetNsamples(); iSample++)
    {
      // Obtain sample name and create a TString version for histogram naming
      std::string name = Sample->GetSampleTitle(iSample);
      TString NameTString = TString(name.c_str());
 
      // Clone the 1D histogram with a modified name
      Sample->AddData(iSample, Sample->GetMCArray(iSample));
    }
    Handlers[i] = Sample;
  }
  return Handlers;
}