#include <Py8GunBase.h>

Inheritance diagram for gen::Py8GunBase:

Public Member Functions
void	finalizeEvent ()

bool	initializeForInternalPartons ()

	Py8GunBase (edm::ParameterSet const &ps)

virtual bool	residualDecay ()

void	setRandomEngine (CLHEP::HepRandomEngine *v)

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

void	statistics ()

	~Py8GunBase ()

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	p8SetRandomEngine (CLHEP::HepRandomEngine *v)

	Py8InterfaceBase (edm::ParameterSet const &ps)

P8RndmEngine &	randomEngine ()

bool	readSettings (int)

	~Py8InterfaceBase ()

Public Member Functions inherited from gen::BaseHadronizer
	BaseHadronizer (edm::ParameterSet const &ps)

void	cleanLHE ()

void	generateLHE (edm::LuminosityBlock const &lumi, CLHEP::HepRandomEngine *rengine)

edm::Event &	getEDMEvent () const

HepMC::GenEvent *	getGenEvent ()

GenEventInfoProduct *	getGenEventInfo ()

virtual GenLumiInfoHeader *	getGenLumiInfoHeader () const

GenRunInfoProduct &	getGenRunInfo ()

const boost::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 (HepMC::GenEvent *event)

void	resetEventInfo (GenEventInfoProduct *eventInfo)

virtual bool	select (HepMC::GenEvent *) const

void	setEDMEvent (edm::Event &event)

void	setLHEEvent (lhef::LHEEvent *event)

void	setLHERunInfo (lhef::LHERunInfo *runInfo)

void	setRandomEngine (CLHEP::HepRandomEngine *v)

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

	~BaseHadronizer ()

Protected Attributes
double	fMaxPhi

double	fMinPhi

std::vector< int >	fPartIDs

Protected Attributes inherited from gen::Py8InterfaceBase
HepMC::IO_AsciiParticles *	ascii_io

std::auto_ptr< EvtGenDecays >	evtgenDecays

std::string	evtgenDecFile

std::string	evtgenPdlFile

std::vector< std::string >	evtgenUserFiles

std::auto_ptr< Pythia8::Pythia >	fDecayer

std::auto_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::auto_ptr< HepMC::GenEvent > &	event ()

std::auto_ptr < GenEventInfoProduct > &	eventInfo ()

lhef::LHEEvent *	lheEvent ()

lhef::LHERunInfo *	lheRunInfo ()

GenRunInfoProduct &	runInfo ()

Detailed Description

Definition at line 42 of file Py8GunBase.h.

Constructor & Destructor Documentation

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

gen::Py8GunBase::~Py8GunBase ( )

inline

Definition at line 45 of file Py8GunBase.h.

45 {}

Member Function Documentation

void gen::Py8GunBase::finalizeEvent ( )

virtual

Implements gen::Py8InterfaceBase.

Definition at line 118 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;
 }

bool gen::Py8GunBase::initializeForInternalPartons ( )

virtual

Implements gen::Py8InterfaceBase.

Definition at line 36 of file Py8GunBase.cc.

References gen::Py8InterfaceBase::evtgenDecays, gen::Py8InterfaceBase::evtgenDecFile, gen::Py8InterfaceBase::evtgenPdlFile, gen::Py8InterfaceBase::evtgenUserFiles, gen::Py8InterfaceBase::fDecayer, gen::Py8InterfaceBase::fMasterGen, 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.c_str(), evtgenPdlFile.c_str()));
 
     for (unsigned int i=0; i<evtgenUserFiles.size(); i++) {
       edm::FileInPath evtgenUserFile(evtgenUserFiles.at(i));
       evtgenDecays->readDecayFile(evtgenUserFile.fullPath().c_str());
     }
   }
 
   return true;
 
 }

bool gen::Py8GunBase::residualDecay ( )

virtual

Definition at line 67 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;
 
 }

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

inline

Definition at line 52 of file Py8GunBase.h.

References gen::Py8InterfaceBase::p8SetRandomEngine().

52 { p8SetRandomEngine(v); }

gen::Py8InterfaceBase::p8SetRandomEngine

void p8SetRandomEngine(CLHEP::HepRandomEngine *v)

Definition: Py8InterfaceBase.h:41

gen::v

double v[5][pyjets_maxn]

Definition: Cascade2Hadronizer.cc:80

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

inline

Definition at line 53 of file Py8GunBase.h.

References p8SharedResources.

53 { return p8SharedResources; }

gen::Py8GunBase::p8SharedResources

static const std::vector< std::string > p8SharedResources

Definition: Py8GunBase.h:63

void gen::Py8GunBase::statistics ( )

virtual

Reimplemented from gen::Py8InterfaceBase.

Definition at line 152 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;
 
 }