#include <ThePEGInterface.h>

Inheritance diagram for ThePEGInterface:

Public Member Functions
void	setPEGRandomEngine (CLHEP::HepRandomEngine *)

	ThePEGInterface (const edm::ParameterSet &params)

virtual	~ThePEGInterface ()

Protected Member Functions
std::string	dataFile (const std::string &fileName) const

std::string	dataFile (const edm::ParameterSet &pset, const std::string &paramName) const

void	flushRandomNumberGenerator ()

void	initGenerator ()

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

Static Protected Member Functions
static void	clearAuxiliary (HepMC::GenEvent hepmc, HepMC::PdfInfo pdf)

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

static void	fillAuxiliary (HepMC::GenEvent hepmc, HepMC::PdfInfo pdf, const ThePEG::EventPtr &event)

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

Protected Attributes
ThePEG::EGPtr	eg_

std::auto_ptr < HepMC::IO_BaseClass >	iobc_

Private Attributes
const std::string	dataLocation_

const std::string	dumpConfig_

const std::string	generator_

boost::shared_ptr < ThePEG::RandomEngineGlue::Proxy >	randomEngineGlueProxy_

const std::string	run_

const unsigned int	skipEvents_

Detailed Description

Oliver Oberst obers.nosp@m.t@ek.nosp@m.p.uni.nosp@m.-kar.nosp@m.lsruh.nosp@m.e.de Fred-Markus Stober stobe.nosp@m.r@ek.nosp@m.p.uni.nosp@m.-kar.nosp@m.lsruh.nosp@m.e.de

Definition at line 31 of file ThePEGInterface.h.

Constructor & Destructor Documentation

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

Definition at line 47 of file ThePEGInterface.cc.

References dumpConfig_, edm::ParameterSet::getUntrackedParameter(), iobc_, dbtoconf::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", "")),
     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.c_str(), ios::out));
         edm::LogInfo("ThePEGSource") << "Event logging switched on (=> " << dumpEvents << ")";
     }
     // Clear dumpConfig target
     if (!dumpConfig_.empty())
         ofstream cfgDump(dumpConfig_.c_str(), ios_base::trunc);
 }

ThePEGInterface::~ThePEGInterface ( )

virtual

Definition at line 66 of file ThePEGInterface.cc.

References eg_.

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

Member Function Documentation

void ThePEGInterface::clearAuxiliary	(	HepMC::GenEvent *	hepmc,
		HepMC::PdfInfo *	pdf
	)

staticprotected

Definition at line 223 of file ThePEGInterface.cc.

Referenced by ThePEGHadronizer::finalizeEvent(), and ThePEGHadronizer::hadronize().

 {
     if (hepmc) {
         hepmc->set_event_scale(-1.0);
         hepmc->set_alphaQCD(-1.0);
         hepmc->set_alphaQED(-1.0);
     }
     if (pdf) {
         pdf->set_id1(-100);
         pdf->set_id2(-100);
         pdf->set_x1(-1.0);
         pdf->set_x2(-1.0);
         pdf->set_scalePDF(-1.0);
         pdf->set_pdf1(-1.0);
         pdf->set_pdf2(-1.0);
     }
 }

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

staticprotected

Definition at line 216 of file ThePEGInterface.cc.

References fileCollector::convert().

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

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

std::string ThePEGInterface::dataFile ( const std::string & fileName ) const

protected

Referenced by initRepository().

std::string ThePEGInterface::dataFile	(	const edm::ParameterSet &	pset,
		const std::string &	paramName
	)		const

protected

void ThePEGInterface::fillAuxiliary	(	HepMC::GenEvent *	hepmc,
		HepMC::PdfInfo *	pdf,
		const ThePEG::EventPtr &	event
	)

staticprotected

Definition at line 242 of file ThePEGInterface.cc.

References GeV, pileupReCalc_HLTpaths::scale, funct::sqr(), mathSSE::sqrt(), and findQualityFiles::v.

Referenced by ThePEGHadronizer::finalizeEvent(), and ThePEGHadronizer::hadronize().

 {
     if (!event->primaryCollision())
         return;
 
     ThePEG::tcEHPtr eh = ThePEG::dynamic_ptr_cast<ThePEG::tcEHPtr>(
                 event->primaryCollision()->handler());
     double scale = eh->lastScale();
 
     if (hepmc) {
         if (hepmc->event_scale() < 0 && scale > 0)
             hepmc->set_event_scale(std::sqrt(scale) / ThePEG::GeV);
 
         if (hepmc->alphaQCD() < 0)
             hepmc->set_alphaQCD(eh->lastAlphaS());
         if (hepmc->alphaQED() < 0)
             hepmc->set_alphaQED(eh->lastAlphaEM());
     }
 
     if (pdf) {
         const ThePEG::PPair &beams = eh->lastParticles();
         const ThePEG::PPair &partons = eh->lastPartons();
         ThePEG::tcPDFPtr pdf1 = eh->lastExtractor()->getPDF(
                         beams.first->dataPtr());
         ThePEG::tcPDFPtr pdf2 = eh->lastExtractor()->getPDF(
                         beams.second->dataPtr());
         double x1, x2;
 
         if (pdf->id1() == -100) {
             int id = partons.first->id();
             pdf->set_id1(id == 21 ? 0 : id);
         }
         if (pdf->id2() == -100) {
             int id = partons.second->id();
             pdf->set_id2(id == 21 ? 0 : id);
         }
 
         if (pdf->scalePDF() < 0)
             pdf->set_scalePDF(std::sqrt(scale) / ThePEG::GeV);
         else
             scale = ThePEG::sqr(pdf->scalePDF()) * ThePEG::GeV;
 
         if (pdf->x1() < 0) {
             x1 = eh->lastX1();
             pdf->set_x1(x1);
         } else
             x1 = pdf->x1();
 
         if (pdf->x2() < 0) {
             x2 = eh->lastX2();
             pdf->set_x2(x2);
         } else
             x2 = pdf->x2();
 
         if (pdf1 && pdf->pdf1() < 0) {
             double v = pdf1->xfx(beams.first->dataPtr(),
                                  partons.first->dataPtr(),
                                  scale, x1);
             if (v > 0 && x1 > 0)
                 pdf->set_pdf1(v / x1);
             else
                 pdf->set_pdf2(-1.0);
         }
         if (pdf2 && pdf->pdf2() < 0) {
             double v = pdf2->xfx(beams.first->dataPtr(),
                                  partons.first->dataPtr(),
                                  scale, x2);
             if (v > 0 && x2 > 0)
                 pdf->set_pdf2(v / x2);
             else
                 pdf->set_pdf2(-1.0);
         }
     }
 
 }

void ThePEGInterface::flushRandomNumberGenerator ( )

protected

Definition at line 205 of file ThePEGInterface.cc.

References ThePEG::RandomEngineGlue::flush(), and randomEngineGlueProxy_.

Referenced by ThePEGHadronizer::generatePartonsAndHadronize(), ThePEGHadronizer::hadronize(), and initGenerator().

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

void ThePEGInterface::initGenerator ( )

protected

Definition at line 184 of file ThePEGInterface.cc.

References eg_, edm::hlt::Exception, flushRandomNumberGenerator(), generator_, i, run_, skipEvents_, and tmp.

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

 {
     // Get generator from the repository and initialize it
     ThePEG::BaseRepository::CheckObjectDirectory(generator_);
     ThePEG::EGPtr tmp = ThePEG::BaseRepository::GetObject<ThePEG::EGPtr>(generator_);
     if (tmp) {
         eg_ = ThePEG::Repository::makeRun(tmp, run_);
         eg_->initialize();
         edm::LogInfo("ThePEGInterface") << "EventGenerator initialized";
     } else
         throw cms::Exception("ThePEGInterface")
             << "EventGenerator could not be initialized!" << endl;
 
     // Skip events
     for (unsigned int i = 0; i < skipEvents_; i++) {
         flushRandomNumberGenerator();
         eg_->shoot();
         edm::LogInfo("ThePEGInterface") << "Event discarded";
     }
 }

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

protected

Definition at line 99 of file ThePEGInterface.cc.

References gen::ParameterCollector::begin(), dtNoiseDBValidation_cfg::cerr, dataFile(), dumpConfig_, gen::ParameterCollector::end(), generator_, edm::ParameterSet::getParameter(), getDQMSummary::iter, svgfig::load(), dbtoconf::out, randomEngineGlueProxy_, SiPixelLorentzAngle_cfi::read, run_, and contentValuesCheck::ss.

Referenced by ThePEGHadronizer::ThePEGHadronizer().

 {
     /* Initialize the repository from
      * 1. the repository file (default values)
      * 2. the ThePEG config files
      * 3. the CMSSW config blocks
      */
     stringstream logstream;
 
     // Read the repository of serialized default values
     string repository = dataFile(pset, "repository");
     if (!repository.empty()) {
         edm::LogInfo("ThePEGInterface") << "Loading repository (" << repository << ")";
         ThePEG::Repository::load(repository);
     }
 
     if (!getenv("ThePEG_INSTALL_PATH")) {
         vector<string> libdirlist = ThePEG::DynamicLoader::allPaths();
         for(vector<string>::const_iterator libdir = libdirlist.begin();
             libdir < libdirlist.end(); ++libdir) {
             if (libdir->empty() || (*libdir)[0] != '/')
                 continue;
             if (boost::filesystem::exists(*libdir +
                     "/../../share/ThePEG/PDFsets.index")) {
                 setenv("ThePEG_INSTALL_PATH",
                        libdir->c_str(), 0);
                 break;
             }
         }
     }
 
     // Read ThePEG config files to read
     vector<string> configFiles = pset.getParameter<vector<string> >("configFiles");
 
     // Loop over the config files
     for(vector<string>::const_iterator iter = configFiles.begin();
         iter != configFiles.end(); ++iter) {
         edm::LogInfo("ThePEGInterface") << "Reading config file (" << *iter << ")";
                 ThePEG::Repository::read(dataFile(*iter), logstream);
                 edm::LogInfo("ThePEGSource") << logstream.str();
     }
 
     // Read CMSSW config file parameter sets starting from "parameterSets"
 
     ofstream cfgDump;
     ParameterCollector collector(pset);
     ParameterCollector::const_iterator iter;
     if (!dumpConfig_.empty()) {
         cfgDump.open(dumpConfig_.c_str(), ios_base::app);
         iter = collector.begin(cfgDump);
     } else
         iter = collector.begin();
 
     for(; iter != collector.end(); ++iter) {
         string out = ThePEG::Repository::exec(*iter, logstream);
         if (!out.empty()) {
             edm::LogInfo("ThePEGInterface") << *iter << " => " << out;
             cerr << "Error in ThePEG configuration!\n"
                     "\tLine: " << *iter << "\n" << out << endl;
         }
     }
 
     if (!dumpConfig_.empty()) {
         cfgDump << "saverun " << run_ << " " << generator_ << endl;
         cfgDump.close();
     }
 
     // write the ProxyID for the RandomEngineGlue to fill its pointer in
     ostringstream ss;
     ss << randomEngineGlueProxy_->getID();
     ThePEG::Repository::exec("set " + generator_ +
                              ":RandomNumberGenerator:ProxyID " + ss.str(),
                              logstream);
 
     // Print the directories where ThePEG looks for libs
     vector<string> libdirlist = ThePEG::DynamicLoader::allPaths();
     for(vector<string>::const_iterator libdir = libdirlist.begin();
         libdir < libdirlist.end(); ++libdir)
         edm::LogInfo("ThePEGInterface") << "DynamicLoader path = " << *libdir << endl;
 
     // Output status information about the repository
     ThePEG::Repository::stats(logstream);
     edm::LogInfo("ThePEGInterface") << logstream.str();
 }

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

staticprotected

Definition at line 320 of file ThePEGInterface.cc.

References GeV, min(), and tmp.

Referenced by ThePEGHadronizer::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();
     for(PVector::const_iterator it = sub->outgoing().begin();
         it != sub->outgoing().end(); ++it)
         pthat = std::min(pthat, (*it)->momentum().perp());
 
     return pthat / ThePEG::GeV;
 }

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

Definition at line 73 of file ThePEGInterface.cc.

References randomEngineGlueProxy_, and ThePEG::RandomEngineGlue::setRandomEngine().

Referenced by ThePEGHadronizer::doSetRandomEngine().

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