gen::Py8GunBase Class Reference

#include <Py8GunBase.h>

Inheritance diagram for gen::Py8GunBase:

Public Member Functions
void	evtGenDecay ()
void	finalizeEvent () override
bool	initializeForInternalPartons () override
	Py8GunBase (edm::ParameterSet const &ps)
virtual bool	residualDecay ()
void	setRandomEngine (CLHEP::HepRandomEngine *v)
std::vector< std::string > const &	sharedResources () const
void	statistics () override
	~Py8GunBase () override
Public Member Functions inherited from gen::Py8InterfaceBase
virtual const char *	classname () const =0
bool	decay ()
bool	declareSpecialSettings (const std::vector< std::string > &)
bool	declareStableParticles (const std::vector< int > &)
virtual bool	generatePartonsAndHadronize ()=0
void	makeTmpSLHA (const std::string &)
void	p8SetRandomEngine (CLHEP::HepRandomEngine *v)
	Py8InterfaceBase (edm::ParameterSet const &ps)
P8RndmEngine &	randomEngine ()
bool	readSettings (int)
	~Py8InterfaceBase () override
Public Member Functions inherited from gen::BaseHadronizer
	BaseHadronizer (edm::ParameterSet const &ps)
void	cleanLHE ()
void	generateLHE (edm::LuminosityBlock const &lumi, CLHEP::HepRandomEngine *rengine, unsigned int ncpu)
edm::Event &	getEDMEvent () const
std::unique_ptr< HepMC::GenEvent >	getGenEvent ()
std::unique_ptr< GenEventInfoProduct >	getGenEventInfo ()
virtual std::unique_ptr< GenLumiInfoHeader >	getGenLumiInfoHeader () const
GenRunInfoProduct &	getGenRunInfo ()
std::unique_ptr< lhef::LHEEvent >	getLHEEvent ()
const std::shared_ptr< lhef::LHERunInfo > &	getLHERunInfo () const
const std::string &	gridpackPath () const
int	randomIndex () const
const std::string &	randomInitConfigDescription () const
void	randomizeIndex (edm::LuminosityBlock const &lumi, CLHEP::HepRandomEngine *rengine)
void	resetEvent (std::unique_ptr< HepMC::GenEvent > event)
void	resetEventInfo (std::unique_ptr< GenEventInfoProduct > eventInfo)
virtual bool	select (HepMC::GenEvent *) const
void	setEDMEvent (edm::Event &event)
void	setLHEEvent (std::unique_ptr< lhef::LHEEvent > event)
void	setLHERunInfo (std::unique_ptr< lhef::LHERunInfo > runInfo)
void	setRandomEngine (CLHEP::HepRandomEngine *v)
std::vector< std::string > const &	sharedResources () const
virtual	~BaseHadronizer () noexcept(false)

Protected Attributes
double	fMaxPhi
double	fMinPhi
std::vector< int >	fPartIDs
Protected Attributes inherited from gen::Py8InterfaceBase
HepMC::IO_AsciiParticles *	ascii_io
std::shared_ptr< Pythia8::EvtGenDecays >	evtgenDecays
std::string	evtgenDecFile
std::string	evtgenPdlFile
std::vector< std::string >	evtgenUserFiles
std::unique_ptr< Pythia8::Pythia >	fDecayer
std::unique_ptr< Pythia8::Pythia >	fMasterGen
edm::ParameterSet	fParameters
unsigned int	maxEventsToPrint
bool	pythiaHepMCVerbosity
bool	pythiaHepMCVerbosityParticles
unsigned int	pythiaPylistVerbosity
std::string	slhafile_
HepMC::Pythia8ToHepMC	toHepMC
bool	useEvtGen
Protected Attributes inherited from gen::BaseHadronizer
std::string	lheFile_
int	randomIndex_

Static Private Attributes
static const std::vector< std::string >	p8SharedResources = {edm::SharedResourceNames::kPythia8}

Additional Inherited Members
Protected Member Functions inherited from gen::BaseHadronizer
std::unique_ptr< HepMC::GenEvent > &	event ()
std::unique_ptr< GenEventInfoProduct > &	eventInfo ()
lhef::LHEEvent *	lheEvent ()
lhef::LHERunInfo *	lheRunInfo ()
GenRunInfoProduct &	runInfo ()

Detailed Description

Definition at line 40 of file Py8GunBase.h.

Constructor & Destructor Documentation

Py8GunBase()

gen::Py8GunBase::Py8GunBase

(

edm::ParameterSet const &

ps

)

Definition at line 15 of file Py8GunBase.cc.

References fMaxPhi, fMinPhi, fPartIDs, and edm::ParameterSet::getParameter().

                                                  : Py8InterfaceBase(ps) {
    // PGun specs
    //
    edm::ParameterSet pgun_params = ps.getParameter<edm::ParameterSet>("PGunParameters");

    // although there's the method ParameterSet::empty(),
    // it looks like it's NOT even necessary to check if it is,
    // before trying to extract parameters - if it is empty,
    // the default values seem to be taken
    //
    fPartIDs = pgun_params.getParameter<std::vector<int> >("ParticleID");
    fMinPhi = pgun_params.getParameter<double>("MinPhi");  // ,-3.14159265358979323846);
    fMaxPhi = pgun_params.getParameter<double>("MaxPhi");  // , 3.14159265358979323846);
  }

~Py8GunBase()

gen::Py8GunBase::~Py8GunBase ( )

inlineoverride

Definition at line 43 of file Py8GunBase.h.

{}

Member Function Documentation

evtGenDecay()

void gen::Py8GunBase::evtGenDecay

(

)

Definition at line 144 of file Py8GunBase.cc.

References gen::Py8InterfaceBase::evtgenDecays.

Referenced by gen::Py8PtAndDxyGun::generatePartonsAndHadronize(), gen::Py8PtotGun::generatePartonsAndHadronize(), gen::Py8PtGun::generatePartonsAndHadronize(), and gen::Py8EGun::generatePartonsAndHadronize().

                               {
    if (evtgenDecays.get())
      evtgenDecays->decay();
  }

finalizeEvent()

void gen::Py8GunBase::finalizeEvent ( )

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 110 of file Py8GunBase.cc.

References gen::Py8InterfaceBase::ascii_io, gather_cfg::cout, gen::BaseHadronizer::event(), gen::Py8InterfaceBase::fMasterGen, gen::Py8InterfaceBase::maxEventsToPrint, gen::Py8InterfaceBase::pythiaHepMCVerbosity, gen::Py8InterfaceBase::pythiaHepMCVerbosityParticles, and gen::Py8InterfaceBase::pythiaPylistVerbosity.

                                 {
    //******** Verbosity ********

    if (maxEventsToPrint > 0 && (pythiaPylistVerbosity || pythiaHepMCVerbosity || pythiaHepMCVerbosityParticles)) {
      maxEventsToPrint--;
      if (pythiaPylistVerbosity) {
        fMasterGen->info.list();
        fMasterGen->event.list();
      }

      if (pythiaHepMCVerbosity) {
        std::cout << "Event process = " << fMasterGen->info.code() << "\n"
                  << "----------------------" << std::endl;
        event()->print();
      }
      if (pythiaHepMCVerbosityParticles) {
        std::cout << "Event process = " << fMasterGen->info.code() << "\n"
                  << "----------------------" << std::endl;
        ascii_io->write_event(event().get());
      }
    }

    return;
  }

initializeForInternalPartons()

bool gen::Py8GunBase::initializeForInternalPartons ( )

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 32 of file Py8GunBase.cc.

References gen::Py8InterfaceBase::evtgenDecays, gen::Py8InterfaceBase::evtgenDecFile, gen::Py8InterfaceBase::evtgenPdlFile, gen::Py8InterfaceBase::evtgenUserFiles, gen::Py8InterfaceBase::fDecayer, gen::Py8InterfaceBase::fMasterGen, mps_fire::i, and gen::Py8InterfaceBase::useEvtGen.

                                                {
    // NO MATTER what was this setting below, override it before init
    // - this is essencial for the PGun mode

    // Key requirement: switch off ProcessLevel, and thereby also PartonLevel.
    fMasterGen->readString("ProcessLevel:all = off");
    fMasterGen->readString("ProcessLevel::resonanceDecays=on");
    fMasterGen->init();

    // init decayer
    fDecayer->readString("ProcessLevel:all = off");  // Same trick!
    fDecayer->readString("ProcessLevel::resonanceDecays=on");
    fDecayer->init();

    if (useEvtGen) {
      edm::LogInfo("Pythia8Interface") << "Creating and initializing pythia8 EvtGen plugin";
      evtgenDecays.reset(new EvtGenDecays(fMasterGen.get(), evtgenDecFile, evtgenPdlFile));
      for (unsigned int i = 0; i < evtgenUserFiles.size(); i++)
        evtgenDecays->readDecayFile(evtgenUserFiles.at(i));
    }

    return true;
  }

residualDecay()

bool gen::Py8GunBase::residualDecay ( )

virtual

Definition at line 56 of file Py8GunBase.cc.

References gen::BaseHadronizer::event(), gen::Py8InterfaceBase::fDecayer, gen::Py8InterfaceBase::fMasterGen, GenParticle::GenParticle, mps_fire::result, and gen::Py8InterfaceBase::toHepMC.

                                 {
    Event* pythiaEvent = &(fMasterGen->event);

    int NPartsBeforeDecays = pythiaEvent->size() - 1;  // do NOT count the very 1st "system" particle
                                                       // in Pythia8::Event record; it does NOT even
                                                       // get translated by the HepMCInterface to the
                                                       // HepMC::GenEvent record !!!
    int NPartsAfterDecays = event().get()->particles_size();

    if (NPartsAfterDecays == NPartsBeforeDecays)
      return true;

    bool result = true;

    for (int ipart = NPartsAfterDecays; ipart > NPartsBeforeDecays; ipart--) {
      HepMC::GenParticle* part = event().get()->barcode_to_particle(ipart);

      if (part->status() == 1 && (fDecayer->particleData).canDecay(part->pdg_id())) {
        fDecayer->event.reset();
        Particle py8part(part->pdg_id(),
                         93,
                         0,
                         0,
                         0,
                         0,
                         0,
                         0,
                         part->momentum().x(),
                         part->momentum().y(),
                         part->momentum().z(),
                         part->momentum().t(),
                         part->generated_mass());
        HepMC::GenVertex* ProdVtx = part->production_vertex();
        py8part.vProd(
            ProdVtx->position().x(), ProdVtx->position().y(), ProdVtx->position().z(), ProdVtx->position().t());
        py8part.tau((fDecayer->particleData).tau0(part->pdg_id()));
        fDecayer->event.append(py8part);
        int nentries = fDecayer->event.size();
        if (!fDecayer->event[nentries - 1].mayDecay())
          continue;
        fDecayer->next();
        int nentries1 = fDecayer->event.size();
        if (nentries1 <= nentries)
          continue;  //same number of particles, no decays...

        part->set_status(2);

        result = toHepMC.fill_next_event(*(fDecayer.get()), event().get(), -1, true, part);
      }
    }

    return result;
  }

setRandomEngine()

void gen::Py8GunBase::setRandomEngine ( CLHEP::HepRandomEngine *  v )

inline

Definition at line 50 of file Py8GunBase.h.

References gen::Py8InterfaceBase::p8SetRandomEngine(), and gen::v.

{ p8SetRandomEngine(v); }

sharedResources()

std::vector<std::string> const& gen::Py8GunBase::sharedResources ( ) const

inline

Definition at line 51 of file Py8GunBase.h.

References p8SharedResources.

{ return p8SharedResources; }

statistics()

void gen::Py8GunBase::statistics ( )

overridevirtual

Reimplemented from gen::Py8InterfaceBase.

Definition at line 135 of file Py8GunBase.cc.

References gen::Py8InterfaceBase::fMasterGen, gen::BaseHadronizer::runInfo(), and GenRunInfoProduct::setInternalXSec().

                              {
    fMasterGen->stat();

    double xsec = fMasterGen->info.sigmaGen();  // cross section in mb
    xsec *= 1.0e9;                              // translate to pb (CMS/Gen "convention" as of May 2009)
    runInfo().setInternalXSec(xsec);
    return;
  }

Member Data Documentation

fMaxPhi

double gen::Py8GunBase::fMaxPhi

protected

Definition at line 59 of file Py8GunBase.h.

Referenced by gen::Py8PtAndDxyGun::generatePartonsAndHadronize(), gen::Py8PtGun::generatePartonsAndHadronize(), gen::Py8PtotGun::generatePartonsAndHadronize(), gen::Py8EGun::generatePartonsAndHadronize(), gen::Py8JetGun::generatePartonsAndHadronize(), gen::Py8MassGun::generatePartonsAndHadronize(), and Py8GunBase().

fMinPhi

double gen::Py8GunBase::fMinPhi

protected

Definition at line 58 of file Py8GunBase.h.

Referenced by gen::Py8PtAndDxyGun::generatePartonsAndHadronize(), gen::Py8PtGun::generatePartonsAndHadronize(), gen::Py8PtotGun::generatePartonsAndHadronize(), gen::Py8EGun::generatePartonsAndHadronize(), gen::Py8JetGun::generatePartonsAndHadronize(), gen::Py8MassGun::generatePartonsAndHadronize(), and Py8GunBase().

fPartIDs

std::vector<int> gen::Py8GunBase::fPartIDs

protected

Definition at line 57 of file Py8GunBase.h.

Referenced by gen::Py8PtAndDxyGun::generatePartonsAndHadronize(), gen::Py8PtGun::generatePartonsAndHadronize(), gen::Py8PtotGun::generatePartonsAndHadronize(), gen::Py8EGun::generatePartonsAndHadronize(), gen::Py8JetGun::generatePartonsAndHadronize(), gen::Py8MassGun::generatePartonsAndHadronize(), and Py8GunBase().

p8SharedResources

const std::vector< std::string > gen::Py8GunBase::p8SharedResources = {edm::SharedResourceNames::kPythia8}

staticprivate

Definition at line 62 of file Py8GunBase.h.

Referenced by sharedResources().