MaCh3Factory.cpp File Reference

#include "Fitters/MaCh3Factory.h"

Include dependency graph for MaCh3Factory.cpp:

Go to the source code of this file.

Functions
std::unique_ptr< FitterBase >	MaCh3FitterFactory (manager *fitMan)
std::unique_ptr< manager >	MaCh3ManagerFactory (int argc, char **argv)

Function Documentation

MaCh3FitterFactory()

std::unique_ptr<FitterBase> MaCh3FitterFactory

(

manager *

fitMan

)

Definition at line 5 of file MaCh3Factory.cpp.

                                                              {
// ********************************************
  std::unique_ptr<FitterBase> MaCh3Fitter = nullptr;
 
  auto Algorithm = GetFromManager<std::string>(fitMan->raw()["General"]["FittingAlgorithm"], "MCMC");
 
  if(Algorithm == "MCMC" || Algorithm == "MR2T2") 
  {
    MaCh3Fitter = std::make_unique<MR2T2>(fitMan);
  }
  else if (Algorithm == "DelayedMCMC"  || Algorithm == "DelayedMR2T2")
  {
    MaCh3Fitter = std::make_unique<DelayedMR2T2>(fitMan);
  }
  else if (Algorithm == "PSO")
  {
    MaCh3Fitter = std::make_unique<PSO>(fitMan);
  }
  else if (Algorithm == "Minuit2")
  {
    #ifdef MaCh3_MINUIT2
    MaCh3Fitter = std::make_unique<MinuitFit>(fitMan);
    #else
    MACH3LOG_ERROR("Trying to use Minuit2 however MaCh3 was compiled without Minuit2 support");
    throw MaCh3Exception(__FILE__ , __LINE__ );
    #endif
  }
  else
  {
    MACH3LOG_ERROR("You want to use algorithm {}, I don't recognize it, sry", Algorithm);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
  return MaCh3Fitter;
}

MaCh3ManagerFactory()

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

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