Inheritance diagram for gen::Py8PtAndLxyGun:

Public Member Functions
const char *	classname () const override

bool	generatePartonsAndHadronize () override

	Py8PtAndLxyGun (edm::ParameterSet const &)

	~Py8PtAndLxyGun () 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< HepMC3::GenEvent >	getGenEvent3 ()

std::unique_ptr< GenEventInfoProduct >	getGenEventInfo ()

std::unique_ptr< GenEventInfoProduct3 >	getGenEventInfo3 ()

virtual std::unique_ptr< GenLumiInfoHeader >	getGenLumiInfoHeader () const

GenRunInfoProduct &	getGenRunInfo ()

std::unique_ptr< lhef::LHEEvent >	getLHEEvent ()

const std::shared_ptr< lhef::LHERunInfo > &	getLHERunInfo () const

unsigned int	getVHepMC ()

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	resetEvent3 (std::unique_ptr< HepMC3::GenEvent > event3)

void	resetEventInfo (std::unique_ptr< GenEventInfoProduct > eventInfo)

void	resetEventInfo3 (std::unique_ptr< GenEventInfoProduct3 > 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	fConeH

double	fConeRadius

double	fDistanceToAPEX

double	fDxyMax

double	fDzMax

double	fLxyBackFraction

double	fLxyMax

double	fLxyMin

double	fLzMax

double	fLzOppositeFraction

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< HepMC3::GenEvent > &	event3 ()

std::unique_ptr< GenEventInfoProduct > &	eventInfo ()

std::unique_ptr< GenEventInfoProduct3 > &	eventInfo3 ()

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
unsigned int	ivhepmc = 2

std::string	lheFile_

int	randomIndex_

Detailed Description

Definition at line 11 of file Py8PtAndLxyGun.cc.

Constructor & Destructor Documentation

◆ Py8PtAndLxyGun()

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

Definition at line 40 of file Py8PtAndLxyGun.cc.

References fAddAntiParticle, fConeH, fConeRadius, fDistanceToAPEX, fDxyMax, fDzMax, fLxyBackFraction, fLxyMax, fLxyMin, fLzMax, fLzOppositeFraction, fMaxEta, fMaxPt, fMinEta, fMinPt, and edm::ParameterSet::getParameter().

                                                           : Py8GunBase(ps) {
     edm::ParameterSet pgun_params = ps.getParameter<edm::ParameterSet>("PGunParameters");
     fMinEta = pgun_params.getParameter<double>("MinEta");
     fMaxEta = pgun_params.getParameter<double>("MaxEta");
     fMinPt = pgun_params.getParameter<double>("MinPt");
     fMaxPt = pgun_params.getParameter<double>("MaxPt");
     fAddAntiParticle = pgun_params.getParameter<bool>("AddAntiParticle");
     fDxyMax = pgun_params.getParameter<double>("dxyMax");
     fDzMax = pgun_params.getParameter<double>("dzMax");
     fLxyMin = pgun_params.getParameter<double>("LxyMin");
     fLxyMax = pgun_params.getParameter<double>("LxyMax");
     fLzMax = pgun_params.getParameter<double>("LzMax");
     fConeRadius = pgun_params.getParameter<double>("ConeRadius");
     fConeH = pgun_params.getParameter<double>("ConeH");
     fDistanceToAPEX = pgun_params.getParameter<double>("DistanceToAPEX");
     fLxyBackFraction = std::clamp(pgun_params.getParameter<double>("LxyBackFraction"), 0., 1.);
     fLzOppositeFraction = std::clamp(pgun_params.getParameter<double>("LzOppositeFraction"), 0., 1.);
   }

◆ ~Py8PtAndLxyGun()

gen::Py8PtAndLxyGun::~Py8PtAndLxyGun ( )

inlineoverride

Definition at line 14 of file Py8PtAndLxyGun.cc.

14 {}

Member Function Documentation

◆ classname()

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

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 199 of file Py8PtAndLxyGun.cc.

199 { return "Py8PtAndLxyGun"; }

◆ generatePartonsAndHadronize()

bool gen::Py8PtAndLxyGun::generatePartonsAndHadronize ( )

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 59 of file Py8PtAndLxyGun.cc.

References funct::abs(), mps_setup::append, funct::cos(), PVValHelper::dxy, PVValHelper::dz, PVValHelper::eta, gen::BaseHadronizer::event(), gen::Py8GunBase::evtGenDecay(), JetChargeProducer_cfi::exp, fAddAntiParticle, fConeH, fConeRadius, fDistanceToAPEX, fDxyMax, fDzMax, gen::P8RndmEngine::flat(), fLxyBackFraction, fLxyMax, fLxyMin, fLzMax, fLzOppositeFraction, gen::Py8InterfaceBase::fMasterGen, fMaxEta, gen::Py8GunBase::fMaxPhi, fMaxPt, fMinEta, gen::Py8GunBase::fMinPhi, fMinPt, gen::Py8GunBase::fPartIDs, mps_fire::i, dqmiolumiharvest::j, dqm-mbProfile::log, M_PI, EgHLTOffHistBins_cfi::mass, EgammaObjectsElectrons_cfi::particleID, DiDispStaMuonMonitor_cfi::pt, multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, gen::Py8InterfaceBase::randomEngine(), Validation_hcalonly_cfi::sign, funct::sin(), mathSSE::sqrt(), funct::tan(), metsig::tau, theta(), hcalRecHitTable_cff::time, gen::Py8InterfaceBase::toHepMC, btvMC_cff::vx, btvMC_cff::vy, and btvMC_cff::vz.

                                                    {
     fMasterGen->event.reset();
 
     for (size_t i = 0; i < fPartIDs.size(); i++) {
       int particleID = fPartIDs[i];  // this is PDG - need to convert to Py8 ???
 
       double phi = 0;
       double dxy = 0;
       double pt = 0;
       double eta = 0;
       double px = 0;
       double py = 0;
       double pz = 0;
       double mass = 0;
       double ee = 0;
       double vx = 0;
       double vy = 0;
       double vz = 0;
       double lxy = 0;
 
       bool passLoop = false;
       while (!passLoop) {
         bool passDxy = false;
         bool passLz = false;
         bool passDz = false;
 
         phi = (fMaxPhi - fMinPhi) * randomEngine().flat() + fMinPhi;
         pt = (fMaxPt - fMinPt) * randomEngine().flat() + fMinPt;
         px = pt * cos(phi);
         py = pt * sin(phi);
 
         lxy = (fLxyMax - fLxyMin) * randomEngine().flat() + fLxyMin;
 
         int sign = 1;
         for (int i = 0; i < 10000; i++) {
           double vphi = 2 * M_PI * randomEngine().flat();
           vx = lxy * cos(vphi);
           vy = lxy * sin(vphi);
 
           dxy = -vx * sin(phi) + vy * cos(phi);
 
           sign = 1;
           if (fLxyBackFraction > 0 && randomEngine().flat() <= fLxyBackFraction) {
             sign = -1;
           }
           if ((std::abs(dxy) < fDxyMax || fDxyMax < 0) && sign * (vx * px + vy * py) > 0) {
             passDxy = true;
             break;
           }
         }
 
         eta = (fMaxEta - fMinEta) * randomEngine().flat() + fMinEta;
         double theta = 2. * atan(exp(-eta));
 
         mass = (fMasterGen->particleData).m0(particleID);
 
         double pp = pt / sin(theta);  // sqrt( ee*ee - mass*mass );
         ee = sqrt(pp * pp + mass * mass);
 
         pz = pp * cos(theta);
 
         float coneTheta = fConeRadius / fConeH;
         for (int j = 0; j < 100; j++) {
           vz = fLzMax * randomEngine().flat();  // this is abs(vz)
           float v0 = vz - fDistanceToAPEX;
           if (v0 <= 0 || lxy * lxy / (coneTheta * coneTheta) > v0 * v0) {
             passLz = true;
             break;
           }
         }
 
         if (fLzOppositeFraction > 0 && randomEngine().flat() <= fLzOppositeFraction)
           sign *= -1;
         if (sign * pz < 0)
           vz = -vz;
 
         double dz = vz - (vx * cos(phi) + vy * sin(phi)) / tan(theta);
         if (std::abs(dz) < fDzMax || fDzMax < 0) {
           passDz = true;
         }
 
         passLoop = (passDxy && passLz && passDz);
         if (passLoop)
           break;
       }
 
       float time = sqrt(vx * vx + vy * vy + vz * vz);
 
       if (!((fMasterGen->particleData).isParticle(particleID))) {
         particleID = std::abs(particleID);
       }
       if (1 <= std::abs(particleID) && std::abs(particleID) <= 6)  // quarks
         (fMasterGen->event).append(particleID, 23, 101, 0, px, py, pz, ee, mass);
       else if (std::abs(particleID) == 21)  // gluons
         (fMasterGen->event).append(21, 23, 101, 102, px, py, pz, ee, mass);
       // other
       else {
         (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);
       }
       (fMasterGen->event).back().vProd(vx, vy, vz, time);
 
       // Here also need to add anti-particle (if any)
       // otherwise just add a 2nd particle of the same type
       // (for example, gamma).
       // Added anti-particle has momentum opposite to corresponding
       // particle, (px,py,pz)=>(-px,-py,-pz), and production vertex
       // symmetric wrt (0,0,0), (vx, vy, vz)=>(-vx, -vy, -vz).
       //
       if (fAddAntiParticle) {
         if (1 <= std::abs(particleID) && std::abs(particleID) <= 6) {  // quarks
           (fMasterGen->event).append(-particleID, 23, 0, 101, -px, -py, -pz, ee, mass);
         } else if (std::abs(particleID) == 21) {  // gluons
           (fMasterGen->event).append(21, 23, 102, 101, -px, -py, -pz, ee, mass);
         } else {
           if ((fMasterGen->particleData).isParticle(-particleID)) {
             (fMasterGen->event).append(-particleID, 1, 0, 0, -px, -py, -pz, ee, mass);
           } else {
             (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);
         }
         (fMasterGen->event).back().vProd(-vx, -vy, -vz, time);
       }
     }
 
     if (!fMasterGen->next())
       return false;
     evtGenDecay();
 
     event() = std::make_unique<HepMC::GenEvent>();
     return toHepMC.fill_next_event(fMasterGen->event, event().get());
   }