#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::unique_ptr< HepMC::GenEvent >	convert (const ThePEG::EventPtr &event)

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

Protected Attributes
std::shared_ptr< Herwig::HerwigUIProvider >	HwUI_

std::unique_ptr< HepMC::IO_BaseClass >	iobc_

Private Attributes
const std::string	dataLocation_

std::string	dumpConfig_

const std::string	generator_

CLHEP::HepRandomEngine *	randomEngine

boost::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 46 of file Herwig7Interface.h.

Constructor & Destructor Documentation

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

Definition at line 54 of file Herwig7Interface.cc.

References dumpConfig_, edm::ParameterSet::getUntrackedParameter(), iobc_, MillePedeFileConverter_cfg::out, and estimatePileup_makeJSON::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 ( )

noexcept

Definition at line 73 of file Herwig7Interface.cc.

References eg_.

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

Member Function Documentation

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 161 of file Herwig7Interface.cc.

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

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

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

staticprotected

Definition at line 246 of file Herwig7Interface.cc.

References fileCollector::convert().

Referenced by Herwig7Hadronizer::generatePartonsAndHadronize().

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

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

protected

Definition at line 278 of file Herwig7Interface.cc.

References gen::ParameterCollector::begin(), dumpConfig_, gen::ParameterCollector::end(), generator_, edm::ParameterSet::getParameter(), randomEngineGlueProxy_, and run_.

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

void Herwig7Interface::flushRandomNumberGenerator ( )

protected

Definition at line 234 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();
       */
 }

bool Herwig7Interface::initGenerator ( )

protected

Definition at line 207 of file Herwig7Interface.cc.

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

Referenced by 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;
 */
     }
 
 }

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

protected

Definition at line 91 of file Herwig7Interface.cc.

References callHerwigGenerator(), createInputFile(), dumpConfig_, edm::ParameterSet::getUntrackedParameter(), HwUI_, run_, AlCaHLTBitMon_QueryRunRegistry::string, and create_public_lumi_plots::transform.

Referenced by Herwig7Hadronizer::Herwig7Hadronizer(), 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);
 
         // construct HerwigUIProvider object and return it as global object
         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;
         }
 
     }
 
 }

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

staticprotected

Definition at line 256 of file Herwig7Interface.cc.

References GeV, and 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;
 }

void Herwig7Interface::setPEGRandomEngine ( CLHEP::HepRandomEngine * v )

Definition at line 80 of file Herwig7Interface.cc.

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

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