Inheritance diagram for gen::Py8JetGun:

Public Member Functions
const char *	classname () const override

bool	generatePartonsAndHadronize () override

	Py8JetGun (edm::ParameterSet const &)

	~Py8JetGun ()

Public Member Functions inherited from gen::Py8GunBase
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
bool	decay ()

bool	declareSpecialSettings (const std::vector< std::string > &)

bool	declareStableParticles (const std::vector< int > &)

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

Private Attributes
double	fMaxE

double	fMaxEta

double	fMaxP

double	fMinE

double	fMinEta

double	fMinP

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

Protected Attributes inherited from gen::Py8GunBase
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_

Detailed Description

Definition at line 9 of file Py8JetGun.cc.

Constructor & Destructor Documentation

gen::Py8JetGun::Py8JetGun ( edm::ParameterSet const & ps )

Definition at line 33 of file Py8JetGun.cc.

References fMaxE, fMaxEta, fMaxP, fMinE, fMinEta, fMinP, and edm::ParameterSet::getParameter().

    : Py8GunBase(ps) 
 {
 
    // ParameterSet defpset ;
    edm::ParameterSet pgun_params = 
       ps.getParameter<edm::ParameterSet>("PGunParameters"); // , defpset ) ;
    fMinEta     = pgun_params.getParameter<double>("MinEta"); // ,-2.2);
    fMaxEta     = pgun_params.getParameter<double>("MaxEta"); // , 2.2);
    fMinP       = pgun_params.getParameter<double>("MinP"); // ,  0.);
    fMaxP       = pgun_params.getParameter<double>("MaxP"); // ,  0.);
    fMinE       = pgun_params.getParameter<double>("MinE"); // ,  0.);
    fMaxE       = pgun_params.getParameter<double>("MaxE"); // ,  0.);
 
 }

gen::Py8JetGun::~Py8JetGun ( )

inline

Definition at line 14 of file Py8JetGun.cc.

14 {}

Member Function Documentation

const char * gen::Py8JetGun::classname ( ) const

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 128 of file Py8JetGun.cc.

 {
    return "Py8JetGun"; 
 }

bool gen::Py8JetGun::generatePartonsAndHadronize ( )

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 49 of file Py8JetGun.cc.

References bitset_utilities::append(), funct::cos(), eta, gen::BaseHadronizer::event(), create_public_lumi_plots::exp, gen::P8RndmEngine::flat(), gen::Py8InterfaceBase::fMasterGen, fMaxE, fMaxEta, fMaxP, gen::Py8GunBase::fMaxPhi, fMinE, fMinEta, fMinP, gen::Py8GunBase::fMinPhi, gen::Py8GunBase::fPartIDs, i, dqm-mbProfile::log, M_PI, ResonanceBuilder::mass, phi(), createTree::pp, gen::Py8InterfaceBase::randomEngine(), funct::sin(), findQualityFiles::size, mathSSE::sqrt(), metsig::tau, and gen::Py8InterfaceBase::toHepMC.

 {
 
    fMasterGen->event.reset();
 
    double totPx = 0.;
    double totPy = 0.;
    double totPz = 0.;
    double totE  = 0.;
    double totM  = 0.;
    double phi, eta, the, ee, pp;
    
    for ( size_t i=0; i<fPartIDs.size(); i++ )
    {
 
       int particleID = fPartIDs[i]; // this is PDG - need to convert to Py8 ???
 
       phi = 2. * M_PI * randomEngine().flat() ;
       the = acos( -1. + 2.*randomEngine().flat() );
 
       // from input
       //
       ee   = (fMaxE-fMinE)*randomEngine().flat() + fMinE;
             
       double mass = (fMasterGen->particleData).m0( particleID );
 
       pp = sqrt( ee*ee - mass*mass );
       
       double px = pp * sin(the) * cos(phi);
       double py = pp * sin(the) * sin(phi);
       double pz = pp * cos(the);
 
       if ( !((fMasterGen->particleData).isParticle( particleID )) )
       {
          particleID = std::fabs(particleID) ;
       }
       (fMasterGen->event).append( particleID, 1, 0, 0, px, py, pz, ee, mass ); 
       int eventSize = (fMasterGen->event).size()-1;
       // -log(flat) = exponential distribution
       double tauTmp = -(fMasterGen->event)[eventSize].tau0() * log(randomEngine().flat());
       (fMasterGen->event)[eventSize].tau( tauTmp );
       
       // values for computing total mass
       //
       totPx += px;
       totPy += py;
       totPz += pz;
       totE  += ee;
 
    }
 
    totM = sqrt( totE*totE - (totPx*totPx+totPy*totPy+totPz*totPz) );
 
    //now the boost (from input params)
    //
    pp = (fMaxP-fMinP)*randomEngine().flat() + fMinP;
    ee = sqrt( totM*totM + pp*pp );   
 
    //the boost direction (from input params)
    //
    phi = (fMaxPhi-fMinPhi)*randomEngine().flat() + fMinPhi;
    eta  = (fMaxEta-fMinEta)*randomEngine().flat() + fMinEta;
    the  = 2.*atan(exp(-eta));
 
    double betaX = pp/ee * std::sin(the) * std::cos(phi);
    double betaY = pp/ee * std::sin(the) * std::sin(phi);
    double betaZ = pp/ee * std::cos(the);  
 
    // boost all particles
    //   
    (fMasterGen->event).bst( betaX, betaY, betaZ );
    
    if ( !fMasterGen->next() ) return false;
    
    event().reset(new HepMC::GenEvent);
    return toHepMC.fill_next_event( fMasterGen->event, event().get() );
   
 }