HerwigUIProvider.cc

Go to the documentation of this file.

#include "GeneratorInterface/Herwig7Interface/interface/HerwigUIProvider.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "GeneratorInterface/Core/interface/ParameterCollector.h"
#include "GeneratorInterface/Herwig7Interface/interface/RandomEngineGlue.h"

#include <ThePEG/Utilities/DynamicLoader.h>
#include <ThePEG/Utilities/Debug.h>
#include <ThePEG/Repository/Repository.h>
#include <ThePEG/Handlers/SamplerBase.h>

namespace Herwig {

  void HerwigUIProvider::quitWithHelp() const {
    edm::LogError("Herwig7Interface") << "An error occured, interface quits now.";
    quit();
  }

  void HerwigUIProvider::quit() const {
    ThePEG::Repository::cleanup();
    edm::LogInfo("Herwig7Interface") << "Quitting HerwigUIProvider after ThePEG repository cleanup.";
  }

  HerwigUIProvider::~HerwigUIProvider() { ThePEG::Repository::cleanup(); }

  HerwigUIProvider::HerwigUIProvider(const edm::ParameterSet &pset, std::string inputFileName, RunMode::Mode runMode)
      : runMode_(runMode),
        resume_(false),
        tics_(true),
        tag_(),
        inputfile_(inputFileName),
        repository_(),
        setupfile_(),
        integrationList_(),
        nEvents_(-1),
        seed_(0),
        jobs_(1),
        jobsize_(0),
        maxjobs_(0) {
    // check runMode of program and terminate if error state
    if (runMode_ == RunMode::ERROR)
      edm::LogError("Herwig7Interface") << "Invalid run mode: RunMode::ERROR was passed to Herwig.\n";

    /*
  std::string tmpRunMode = pset.getUntrackedParameter<std::string>("runMode", "read");
  if      ( tmpRunMode == "init" )       { runMode_ = RunMode::INIT; }
  else if ( tmpRunMode == "read" )       { runMode_ = RunMode::READ; }
  else if ( tmpRunMode == "build" )      { runMode_ = RunMode::BUILD; }
  else if ( tmpRunMode == "integrate" )  { runMode_ = RunMode::INTEGRATE; }
  else if ( tmpRunMode == "mergegrids" ) { runMode_ = RunMode::MERGEGRIDS; }
  else if ( tmpRunMode == "run" )        { runMode_ = RunMode::RUN; }
  else {
    runMode_ = RunMode::ERROR;
    quitWithHelp();
  }
*/

    // File path to repository file
    repository_ = gen::ParameterCollector::resolve(pset.getParameter<std::string>("repository"));
    if (repository_.empty()) {
      repository_ = std::string("HerwigDefaults.rpo");
    }

    // Number of events
    if (pset.getUntrackedParameter<int>("numberEvents", -1) != -1)
      nEvents_ = pset.getUntrackedParameter<int>("numberEvents", 1);

    // run name tag (default given in ggo file)
    if (!pset.getUntrackedParameter<std::string>("runTag", "").empty())
      tag_ = pset.getUntrackedParameter<std::string>("runTag", "Tag1");

    // Debugging level
    if (pset.getUntrackedParameter<unsigned int>("debugOutput", 0))
      ThePEG::Debug::setDebug(pset.getUntrackedParameter<unsigned int>("debugOutput", 0));

    // Floating point exceptions
    if (pset.getUntrackedParameter<bool>("debugFPE", false))
      ThePEG::Debug::unmaskFpuErrors();

    // Exit-on-error flag
    if (pset.getUntrackedParameter<bool>("exitOnError", false))
      ThePEG::Repository::exitOnError() = 1;

    // Tics
    if (pset.getUntrackedParameter<bool>("hideTics", false))
      tics_ = false;

    // RNG seed
    if (pset.getUntrackedParameter<int>("seed", 0) != 0)
      seed_ = pset.getUntrackedParameter<int>("seed", 0);

    // run modification file
    if (!pset.getUntrackedParameter<std::string>("setupFile", "").empty())
      setupfile_ = pset.getUntrackedParameter<std::string>("setupFile", "");

    // parallel jobs
    if (pset.getUntrackedParameter<int>("jobs", 1) != 1)
      jobs_ = pset.getUntrackedParameter<int>("jobs", 1);

    // Directories from which Herwig reads filesystem
    std::vector<std::string> aReadDirectories =
        pset.getUntrackedParameter<std::vector<std::string> >("appendReadDirectories", std::vector<std::string>());
    std::vector<std::string> pReadDirectories =
        pset.getUntrackedParameter<std::vector<std::string> >("prependReadDirectories", std::vector<std::string>());
    appendReadDirectories_.insert(appendReadDirectories_.end(), aReadDirectories.begin(), aReadDirectories.end());
    prependReadDirectories_.insert(prependReadDirectories_.end(), pReadDirectories.begin(), pReadDirectories.end());

    // Library search path for dlopen()
    std::vector<std::string> aPath =
        pset.getUntrackedParameter<std::vector<std::string> >("appendPath", std::vector<std::string>());
    std::vector<std::string> pPath =
        pset.getUntrackedParameter<std::vector<std::string> >("prependPath", std::vector<std::string>());
    for (size_t i = 0; i < aPath.size(); ++i)
      ThePEG::DynamicLoader::appendPath(aPath[i]);
    for (size_t i = 0; i < pPath.size(); ++i)
      ThePEG::DynamicLoader::prependPath(pPath[i]);

    // integration list
    if (!pset.getUntrackedParameter<std::string>("integrationList", "").empty()) {
      integrationList_ = "integrationJob" + pset.getUntrackedParameter<std::string>("integrationList", "1");
    }

    // job size
    if (pset.getUntrackedParameter<unsigned int>("jobSize", 0) != 0) {
      if (runMode_ == RunMode::BUILD) {
        jobsize_ = pset.getUntrackedParameter<unsigned int>("jobSize", 1);
        ThePEG::SamplerBase::setIntegratePerJob(jobsize_);
      }
    }

    // max integration jobs
    if (pset.getUntrackedParameter<unsigned int>("maxJobs", 0) != 0) {
      if (runMode_ == RunMode::BUILD) {
        maxjobs_ = pset.getUntrackedParameter<unsigned int>("maxJobs", 1);
        ThePEG::SamplerBase::setIntegrationJobs(maxjobs_);
      }
    }

    // Resume
    if (pset.getUntrackedParameter<bool>("resume", false))
      resume_ = true;
  }

  void HerwigUIProvider::setRunMode(RunMode::Mode runMode, const edm::ParameterSet &pset, std::string inputFile) {
    runMode_ = runMode;
    if (!inputFile.empty())
      inputfile_ = inputFile;

    /* If build mode is chosen set these parameters accordingly, else unset them.*/
    if (runMode_ == RunMode::BUILD) {
      // job size
      if (pset.getUntrackedParameter<unsigned int>("jobSize", 0) != 0) {
        jobsize_ = pset.getUntrackedParameter<unsigned int>("jobSize", 1);
        ThePEG::SamplerBase::setIntegratePerJob(jobsize_);
      }
      // max integration jobs
      if (pset.getUntrackedParameter<unsigned int>("maxJobs", 0) != 0) {
        maxjobs_ = pset.getUntrackedParameter<unsigned int>("maxJobs", 1);
        ThePEG::SamplerBase::setIntegrationJobs(maxjobs_);
      }
    } else {
      jobsize_ = 0;
      ThePEG::SamplerBase::setIntegratePerJob(jobsize_);
      maxjobs_ = 0;
      ThePEG::SamplerBase::setIntegrationJobs(maxjobs_);
    }
  }
  // End Herwig namespace
}  // namespace Herwig