Herwig7Interface Class Reference

#include <Herwig7Interface.h>

Inheritance diagram for Herwig7Interface:

Public Member Functions
	Herwig7Interface (const edm::ParameterSet &params)
void	setPEGRandomEngine (CLHEP::HepRandomEngine *)
	~Herwig7Interface () noexcept

Public Attributes
ThePEG::EGPtr	eg_

Protected Member Functions
void	callHerwigGenerator ()
void	createInputFile (const edm::ParameterSet &params)
void	flushRandomNumberGenerator ()
bool	initGenerator ()
void	initRepository (const edm::ParameterSet &params)

Static Protected Member Functions
static std::auto_ptr< HepMC::GenEvent >	convert (const ThePEG::EventPtr &event)
static double	pthat (const ThePEG::EventPtr &event)

Protected Attributes
std::shared_ptr< Herwig::HerwigUIProvider >	HwUI_
std::auto_ptr< HepMC::IO_BaseClass >	iobc_

Private Attributes
const std::string	dataLocation_
std::string	dumpConfig_
const std::string	generator_
CLHEP::HepRandomEngine *	randomEngine
std::shared_ptr< ThePEG::RandomEngineGlue::Proxy >	randomEngineGlueProxy_
const std::string	run_
const unsigned int	skipEvents_

Detailed Description

Marco A. Harrendorf marco.nosp@m..har.nosp@m.rendo.nosp@m.rf@c.nosp@m.ern.c.nosp@m.h Dominik Beutel domin.nosp@m.ik.b.nosp@m.eutel.nosp@m.@cer.nosp@m.n.ch

Definition at line 41 of file Herwig7Interface.h.

Constructor & Destructor Documentation

Herwig7Interface()

Herwig7Interface::Herwig7Interface

(

const edm::ParameterSet &

params

)

Definition at line 50 of file Herwig7Interface.cc.

References dumpConfig_, iobc_, MillePedeFileConverter_cfg::out, muonDTDigis_cfi::pset, and pileupReCalc_HLTpaths::trunc.

    : randomEngineGlueProxy_(ThePEG::RandomEngineGlue::Proxy::create()),
      dataLocation_(ParameterCollector::resolve(pset.getParameter<string>("dataLocation"))),
      generator_(pset.getParameter<string>("generatorModule")),
      run_(pset.getParameter<string>("run")),
      dumpConfig_(pset.getUntrackedParameter<string>("dumpConfig", "HerwigConfig.in")),
      skipEvents_(pset.getUntrackedParameter<unsigned int>("skipEvents", 0)) {
  // Write events in hepmc ascii format for debugging purposes
  string dumpEvents = pset.getUntrackedParameter<string>("dumpEvents", "");
  if (!dumpEvents.empty()) {
    iobc_.reset(new HepMC::IO_GenEvent(dumpEvents, ios::out));
    edm::LogInfo("ThePEGSource") << "Event logging switched on (=> " << dumpEvents << ")";
  }
  // Clear dumpConfig target
  if (!dumpConfig_.empty())
    ofstream cfgDump(dumpConfig_.c_str(), ios_base::trunc);
}

~Herwig7Interface()

Herwig7Interface::~Herwig7Interface ( )

noexcept

Definition at line 68 of file Herwig7Interface.cc.

References eg_.

                                             {
  if (eg_)
    eg_->finalize();
  edm::LogInfo("Herwig7Interface") << "Event generator finalized";
}

Member Function Documentation

callHerwigGenerator()

void Herwig7Interface::callHerwigGenerator ( )

protected

Function calls Herwig event generator via API

According to the run mode different steps of event generation are done

Definition at line 139 of file Herwig7Interface.cc.

References newFWLiteAna::build, MillePedeFileConverter_cfg::e, eg_, dqm::qstatus::ERROR, cppFunctionSkipper::exception, Exception, HwUI_, init, randomEngine, and fileinputsource_cfi::read.

Referenced by initGenerator(), and initRepository().

                                           {
  try {
    edm::LogInfo("Herwig7Interface") << "callHerwigGenerator function invoked with run mode " << HwUI_->runMode()
                                     << ".\n";

    // Call program switches according to runMode
    switch (HwUI_->runMode()) {
      case Herwig::RunMode::INIT:
        Herwig::API::init(*HwUI_);
        break;
      case Herwig::RunMode::READ:
        Herwig::API::read(*HwUI_);
        break;
      case Herwig::RunMode::BUILD:
        Herwig::API::build(*HwUI_);
        break;
      case Herwig::RunMode::INTEGRATE:
        Herwig::API::integrate(*HwUI_);
        break;
      case Herwig::RunMode::MERGEGRIDS:
        Herwig::API::mergegrids(*HwUI_);
        break;
      case Herwig::RunMode::RUN: {
        HwUI_->setSeed(randomEngine->getSeed());
        eg_ = Herwig::API::prepareRun(*HwUI_);
        break;
      }
      case Herwig::RunMode::ERROR:
        edm::LogError("Herwig7Interface") << "Error during read in of command line parameters.\n"
                                          << "Program execution will stop now.";
        return;
      default:
        HwUI_->quitWithHelp();
    }

    return;

  } catch (ThePEG::Exception &e) {
    edm::LogError("Herwig7Interface") << ": ThePEG::Exception caught.\n"
                                      << e.what() << '\n'
                                      << "See logfile for details.\n";
    return;
  } catch (std::exception &e) {
    edm::LogError("Herwig7Interface") << ": " << e.what() << '\n';
    return;
  } catch (const char *what) {
    edm::LogError("Herwig7Interface") << ": caught exception: " << what << "\n";
    return;
  }
}

convert()

auto_ptr< HepMC::GenEvent > Herwig7Interface::convert ( const ThePEG::EventPtr &  event )

staticprotected

Definition at line 226 of file Herwig7Interface.cc.

References fileCollector::convert().

Referenced by Herwig7Hadronizer::generatePartonsAndHadronize(), and Herwig7Hadronizer::hadronize().

                                                                             {
  return std::auto_ptr<HepMC::GenEvent>(ThePEG::HepMCConverter<HepMC::GenEvent>::convert(*event));
}

createInputFile()

void Herwig7Interface::createInputFile ( const edm::ParameterSet &  params )

protected

Definition at line 246 of file Herwig7Interface.cc.

References gen::ParameterCollector::begin(), DYToLL_TuneCH3_13TeV_herwig7_cff::configFiles, dumpConfig_, gen::ParameterCollector::end(), generator_, muonDTDigis_cfi::pset, randomEngineGlueProxy_, run_, and contentValuesCheck::ss.

Referenced by initRepository().

                                                                  {
  /* Initialize the input config for Herwig from
     * 1. the Herwig7 config files
     * 2. the CMSSW config blocks
     * Writes them to an output file which is read by Herwig
    */

  stringstream logstream;

  // Contains input config passed to Herwig
  stringstream herwiginputconfig;

  // Define output file to which input config is written, too, if dumpConfig parameter is set.
  // Otherwise use default file HerwigConfig.in which is read in by Herwig
  ofstream cfgDump;
  cfgDump.open(dumpConfig_.c_str(), ios_base::app);

  // Read Herwig config files as input
  vector<string> configFiles = pset.getParameter<vector<string> >("configFiles");
  // Loop over the config files
  for (const auto &iter : configFiles) {
    // Open external config file
    ifstream externalConfigFile(iter);
    if (externalConfigFile.is_open()) {
      edm::LogInfo("Herwig7Interface") << "Reading config file (" << iter << ")" << endl;
      stringstream configFileStream;
      configFileStream << externalConfigFile.rdbuf();
      string configFileContent = configFileStream.str();

      // Comment out occurence of saverun in config file since it is set later considering run and generator option
      string searchKeyword("saverun");
      if (configFileContent.find(searchKeyword) != std::string::npos) {
        edm::LogInfo("Herwig7Interface") << "Commented out saverun command in external input config file(" << iter
                                         << ")" << endl;
        configFileContent.insert(configFileContent.find(searchKeyword), "#");
      }
      herwiginputconfig << "# Begin Config file input" << endl
                        << configFileContent << endl
                        << "# End Config file input";
      edm::LogInfo("Herwig7Interface") << "Finished reading config file (" << iter << ")" << endl;
    } else {
      edm::LogWarning("Herwig7Interface") << "Could not read config file (" << iter << ")" << endl;
    }
  }

  edm::LogInfo("Herwig7Interface") << "Start with processing CMSSW config" << endl;
  // Read CMSSW config file parameter sets starting from "parameterSets"
  ParameterCollector collector(pset);
  ParameterCollector::const_iterator iter;
  iter = collector.begin();
  herwiginputconfig << endl << "# Begin Parameter set input\n" << endl;
  for (; iter != collector.end(); ++iter) {
    herwiginputconfig << *iter << endl;
  }

  // Add some additional necessary lines to the Herwig input config
  herwiginputconfig << "saverun " << run_ << " " << generator_ << endl;
  // write the ProxyID for the RandomEngineGlue to fill its pointer in
  ostringstream ss;
  ss << randomEngineGlueProxy_->getID();
  //herwiginputconfig << "set " << generator_ << ":RandomNumberGenerator:ProxyID " << ss.str() << endl;

  // Dump Herwig input config to file, so that it can be read by Herwig
  cfgDump << herwiginputconfig.str() << endl;
  cfgDump.close();
}

flushRandomNumberGenerator()

void Herwig7Interface::flushRandomNumberGenerator ( )

protected

Definition at line 215 of file Herwig7Interface.cc.

Referenced by initGenerator().

                                                  {
  /*ThePEG::RandomEngineGlue *rnd = randomEngineGlueProxy_->getInstance();

    if (!rnd)
        edm::LogWarning("ProxyMissing")
            << "ThePEG not initialised with RandomEngineGlue.";
    else
        rnd->flush();
      */
}

initGenerator()

bool Herwig7Interface::initGenerator ( )

protected

Definition at line 190 of file Herwig7Interface.cc.

References callHerwigGenerator(), eg_, flushRandomNumberGenerator(), HwUI_, mps_fire::i, and skipEvents_.

Referenced by Herwig7Hadronizer::initializeForExternalPartons(), and Herwig7Hadronizer::initializeForInternalPartons().

                                     {
  if (HwUI_->runMode() == Herwig::RunMode::RUN) {
    edm::LogInfo("Herwig7Interface") << "Starting EventGenerator initialization";
    callHerwigGenerator();
    edm::LogInfo("Herwig7Interface") << "EventGenerator initialized";

    // Skip events
    for (unsigned int i = 0; i < skipEvents_; i++) {
      flushRandomNumberGenerator();
      eg_->shoot();
      edm::LogInfo("Herwig7Interface") << "Event discarded";
    }

    return true;

  } else {
    edm::LogInfo("Herwig7Interface") << "Stopped EventGenerator due to missing run mode.";
    return false;
    /*
        throw cms::Exception("Herwig7Interface")
            << "EventGenerator could not be initialized due to wrong run mode!" << endl;
*/
  }
}

initRepository()

void Herwig7Interface::initRepository ( const edm::ParameterSet &  params )

protected

Definition at line 83 of file Herwig7Interface.cc.

References callHerwigGenerator(), createInputFile(), dumpConfig_, HwUI_, muonDTDigis_cfi::pset, run_, AlCaHLTBitMon_QueryRunRegistry::string, and HcalDetIdTransform::transform().

Referenced by Herwig7Hadronizer::Herwig7Hadronizer(), Herwig7Hadronizer::initializeForExternalPartons(), and Herwig7Hadronizer::initializeForInternalPartons().

                                                                 {
  std::string runModeTemp = pset.getUntrackedParameter<string>("runModeList", "read,run");

  // To Lower
  std::transform(runModeTemp.begin(), runModeTemp.end(), runModeTemp.begin(), ::tolower);

  while (!runModeTemp.empty()) {
    // Split first part of List
    std::string choice;
    size_t pos = runModeTemp.find(',');
    if (std::string::npos == pos)
      choice = runModeTemp;
    else
      choice = runModeTemp.substr(0, pos);

    if (pos == std::string::npos)
      runModeTemp.erase();
    else
      runModeTemp.erase(0, pos + 1);

    HwUI_.reset(new Herwig::HerwigUIProvider(pset, dumpConfig_, Herwig::RunMode::READ));
    edm::LogInfo("Herwig7Interface") << "HerwigUIProvider object with run mode " << HwUI_->runMode() << " created.\n";

    // Chose run mode
    if (choice == "read") {
      createInputFile(pset);
      HwUI_->setRunMode(Herwig::RunMode::READ, pset, dumpConfig_);
      edm::LogInfo("Herwig7Interface") << "Input file " << dumpConfig_
                                       << " will be passed to Herwig for the read step.\n";
      callHerwigGenerator();
    } else if (choice == "build") {
      createInputFile(pset);
      HwUI_->setRunMode(Herwig::RunMode::BUILD, pset, dumpConfig_);
      edm::LogInfo("Herwig7Interface") << "Input file " << dumpConfig_
                                       << " will be passed to Herwig for the build step.\n";
      callHerwigGenerator();

    } else if (choice == "integrate") {
      std::string runFileName = run_ + ".run";
      edm::LogInfo("Herwig7Interface") << "Run file " << runFileName
                                       << " will be passed to Herwig for the integrate step.\n";
      HwUI_->setRunMode(Herwig::RunMode::INTEGRATE, pset, runFileName);
      callHerwigGenerator();

    } else if (choice == "run") {
      std::string runFileName = run_ + ".run";
      edm::LogInfo("Herwig7Interface") << "Run file " << runFileName << " will be passed to Herwig for the run step.\n";
      HwUI_->setRunMode(Herwig::RunMode::RUN, pset, runFileName);
    } else {
      edm::LogInfo("Herwig7Interface") << "Cannot recognize \"" << choice << "\".\n"
                                       << "Trying to skip step.\n";
      continue;
    }
  }
}

pthat()

double Herwig7Interface::pthat ( const ThePEG::EventPtr &  event )

staticprotected

Definition at line 230 of file Herwig7Interface.cc.

References createJobs::tmp.

Referenced by Herwig7Hadronizer::finalizeEvent().

                                                          {
  using namespace ThePEG;

  if (!event->primaryCollision())
    return -1.0;

  tSubProPtr sub = event->primaryCollision()->primarySubProcess();
  TmpTransform<tSubProPtr> tmp(sub, Utilities::getBoostToCM(sub->incoming()));

  double pthat = (*sub->outgoing().begin())->momentum().perp() / ThePEG::GeV;
  for (PVector::const_iterator it = sub->outgoing().begin(); it != sub->outgoing().end(); ++it)
    pthat = std::min<double>(pthat, (*it)->momentum().perp() / ThePEG::GeV);

  return pthat;
}

setPEGRandomEngine()

void Herwig7Interface::setPEGRandomEngine

(

CLHEP::HepRandomEngine *

v

)

Definition at line 74 of file Herwig7Interface.cc.

References randomEngine, randomEngineGlueProxy_, ThePEG::RandomEngineGlue::setRandomEngine(), and findQualityFiles::v.

Referenced by Herwig7Hadronizer::doSetRandomEngine().

                                                                 {
  randomEngineGlueProxy_->setRandomEngine(v);
  randomEngine = v;
  ThePEG::RandomEngineGlue *rnd = randomEngineGlueProxy_->getInstance();
  if (rnd) {
    rnd->setRandomEngine(v);
  }
}

Member Data Documentation

dataLocation_

const std::string Herwig7Interface::dataLocation_

private

Definition at line 77 of file Herwig7Interface.h.

dumpConfig_

std::string Herwig7Interface::dumpConfig_

private

Definition at line 81 of file Herwig7Interface.h.

Referenced by createInputFile(), Herwig7Interface(), and initRepository().

eg_

ThePEG::EGPtr Herwig7Interface::eg_

Definition at line 48 of file Herwig7Interface.h.

Referenced by callHerwigGenerator(), Herwig7Hadronizer::generatePartonsAndHadronize(), Herwig7Hadronizer::hadronize(), initGenerator(), Herwig7Hadronizer::statistics(), and ~Herwig7Interface().

generator_

const std::string Herwig7Interface::generator_

private

Definition at line 78 of file Herwig7Interface.h.

Referenced by createInputFile().

HwUI_

std::shared_ptr<Herwig::HerwigUIProvider> Herwig7Interface::HwUI_

protected

Definition at line 62 of file Herwig7Interface.h.

Referenced by callHerwigGenerator(), initGenerator(), and initRepository().

iobc_

std::auto_ptr<HepMC::IO_BaseClass> Herwig7Interface::iobc_

protected

Definition at line 59 of file Herwig7Interface.h.

Referenced by Herwig7Hadronizer::finalizeEvent(), and Herwig7Interface().

randomEngine

CLHEP::HepRandomEngine* Herwig7Interface::randomEngine

private

Definition at line 83 of file Herwig7Interface.h.

Referenced by callHerwigGenerator(), and setPEGRandomEngine().

randomEngineGlueProxy_

std::shared_ptr<ThePEG::RandomEngineGlue::Proxy> Herwig7Interface::randomEngineGlueProxy_

private

Definition at line 75 of file Herwig7Interface.h.

Referenced by createInputFile(), and setPEGRandomEngine().

run_

const std::string Herwig7Interface::run_

private

Definition at line 79 of file Herwig7Interface.h.

Referenced by createInputFile(), and initRepository().

skipEvents_

const unsigned int Herwig7Interface::skipEvents_

private

Definition at line 82 of file Herwig7Interface.h.

Referenced by initGenerator().