gen::Py8PtExpGun Class Reference

Inheritance diagram for gen::Py8PtExpGun:

Public Member Functions
const char *	classname () const override
bool	generatePartonsAndHadronize () override
	Py8PtExpGun (edm::ParameterSet const &)
	~Py8PtExpGun () override
Public Member Functions inherited from gen::Py8GunBase
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
bool	decay ()
bool	declareSpecialSettings (const std::vector< std::string > &)
bool	declareStableParticles (const std::vector< int > &)
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)

Private Attributes
bool	fAddAntiParticle
double	fMaxEta
double	fMaxPt
double	fMinEta
double	fMinPt

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

Detailed Description

Definition at line 10 of file Py8PtExpGun.cc.

Constructor & Destructor Documentation

Py8PtExpGun()

gen::Py8PtExpGun::Py8PtExpGun

(

edm::ParameterSet const &

ps

)

Definition at line 29 of file Py8PtExpGun.cc.

References fAddAntiParticle, fMaxEta, fMaxPt, fMinEta, fMinPt, 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);
    fMinPt = pgun_params.getParameter<double>("MinPt");                                    // ,  0.);
    fMaxPt = pgun_params.getParameter<double>("MaxPt");                                    // ,  0.);
    fAddAntiParticle = pgun_params.getParameter<bool>("AddAntiParticle");                  //, false) ;
  }

~Py8PtExpGun()

gen::Py8PtExpGun::~Py8PtExpGun ( )

inlineoverride

Definition at line 13 of file Py8PtExpGun.cc.

{}

Member Function Documentation

classname()

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

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 117 of file Py8PtExpGun.cc.

{ return "Py8PtExpGun"; }

generatePartonsAndHadronize()

bool gen::Py8PtExpGun::generatePartonsAndHadronize ( )

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 39 of file Py8PtExpGun.cc.

References funct::abs(), mps_setup::append, funct::cos(), PVValHelper::eta, gen::BaseHadronizer::event(), gen::Py8GunBase::evtGenDecay(), JetChargeProducer_cfi::exp, fAddAntiParticle, gen::P8RndmEngine::flat(), gen::Py8InterfaceBase::fMasterGen, fMaxEta, gen::Py8GunBase::fMaxPhi, fMaxPt, fMinEta, gen::Py8GunBase::fMinPhi, fMinPt, gen::Py8GunBase::fPartIDs, mps_fire::i, dqm-mbProfile::log, EgHLTOffHistBins_cfi::mass, SiStripPI::min, EgammaObjectsElectrons_cfi::particleID, createTree::pp, DiDispStaMuonMonitor_cfi::pt, multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, gen::Py8InterfaceBase::randomEngine(), funct::sin(), findQualityFiles::size, mathSSE::sqrt(), metsig::tau, and gen::Py8InterfaceBase::toHepMC.

                                                {
    fMasterGen->event.reset();

    int NTotParticles = fPartIDs.size();
    if (fAddAntiParticle)
      NTotParticles *= 2;

    // energy below is dummy, it is not used
    (fMasterGen->event).append(990, -11, 0, 0, 2, 1 + NTotParticles, 0, 0, 0., 0., 0., 15000., 15000.);

    for (size_t i = 0; i < fPartIDs.size(); i++) {
      int particleID = fPartIDs[i];  // this is PDG - need to convert to Py8 ???

      double phi = (fMaxPhi - fMinPhi) * randomEngine().flat() + fMinPhi;
      double eta = (fMaxEta - fMinEta) * randomEngine().flat() + fMinEta;
      double the = 2. * atan(exp(-eta));

      //-log(flat) = exponential distribution
      //  need the /10.0 and the min with 1.0 to make sure pt doesn't go too high
      //      10.0 chosen to give last pt bin (overflow bin) a reasonable (not unnaturally high) content
      double pt = (std::min(-1 / 10.0 * log(randomEngine().flat()), 1.0)) * (fMaxPt - fMinPt) + fMinPt;

      double mass = (fMasterGen->particleData).m0(particleID);

      double pp = pt / sin(the);  // sqrt( ee*ee - mass*mass );
      double ee = sqrt(pp * pp + mass * mass);

      double px = pt * cos(phi);
      double py = pt * sin(phi);
      double pz = pp * cos(the);

      if (!((fMasterGen->particleData).isParticle(particleID))) {
        particleID = std::abs(particleID);
      }
      if (1 <= std::abs(particleID) && std::abs(particleID) <= 6)  // quarks
        (fMasterGen->event).append(particleID, 23, 1, 0, 0, 0, 101, 0, px, py, pz, ee, mass);
      else if (std::abs(particleID) == 21)  // gluons
        (fMasterGen->event).append(21, 23, 1, 0, 0, 0, 101, 102, px, py, pz, ee, mass);
      // other
      else {
        (fMasterGen->event).append(particleID, 1, 1, 0, 0, 0, 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);
      }

      // Here also need to add anti-particle (if any)
      // otherwise just add a 2nd particle of the same type
      // (for example, gamma)
      //
      if (fAddAntiParticle) {
        if (1 <= std::abs(particleID) && std::abs(particleID) <= 6) {  // quarks
          (fMasterGen->event).append(-particleID, 23, 1, 0, 0, 0, 0, 101, -px, -py, -pz, ee, mass);
        } else if (std::abs(particleID) == 21) {  // gluons
          (fMasterGen->event).append(21, 23, 1, 0, 0, 0, 102, 101, -px, -py, -pz, ee, mass);
        } else {
          if ((fMasterGen->particleData).isParticle(-particleID)) {
            (fMasterGen->event).append(-particleID, 1, 1, 0, 0, 0, 0, 0, -px, -py, -pz, ee, mass);
          } else {
            (fMasterGen->event).append(particleID, 1, 1, 0, 0, 0, 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);
        }
      }
    }

    if (!fMasterGen->next())
      return false;
    evtGenDecay();

    event() = std::make_unique<HepMC::GenEvent>();
    return toHepMC.fill_next_event(fMasterGen->event, event().get());
  }

Member Data Documentation

fAddAntiParticle

bool gen::Py8PtExpGun::fAddAntiParticle

private

Definition at line 24 of file Py8PtExpGun.cc.

Referenced by generatePartonsAndHadronize(), and Py8PtExpGun().

fMaxEta

double gen::Py8PtExpGun::fMaxEta

private

Definition at line 21 of file Py8PtExpGun.cc.

Referenced by generatePartonsAndHadronize(), and Py8PtExpGun().

fMaxPt

double gen::Py8PtExpGun::fMaxPt

private

Definition at line 23 of file Py8PtExpGun.cc.

Referenced by generatePartonsAndHadronize(), and Py8PtExpGun().

fMinEta

double gen::Py8PtExpGun::fMinEta

private

Definition at line 20 of file Py8PtExpGun.cc.

Referenced by generatePartonsAndHadronize(), and Py8PtExpGun().

fMinPt

double gen::Py8PtExpGun::fMinPt

private

Definition at line 22 of file Py8PtExpGun.cc.

Referenced by generatePartonsAndHadronize(), and Py8PtExpGun().