#include <PyquenHadronizer.h>

Inheritance diagram for gen::PyquenHadronizer:

Public Member Functions
const char *	classname () const

bool	decay ()

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

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

void	finalizeEvent ()

bool	generatePartonsAndHadronize ()

bool	hadronize ()

bool	initializeForExternalPartons ()

bool	initializeForInternalPartons ()

	PyquenHadronizer (const edm::ParameterSet &, edm::ConsumesCollector &&)

bool	readSettings (int)

bool	residualDecay ()

bool	select (HepMC::GenEvent *evtTry) const override

void	statistics ()

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

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 Member Functions
void	add_heavy_ion_rec (HepMC::GenEvent *evt)

void	doSetRandomEngine (CLHEP::HepRandomEngine *v) override

std::vector< std::string > const &	doSharedResources () const override

const char *	nucleon ()

bool	pyqpythia_init (const edm::ParameterSet &pset)

bool	pyquen_init (const edm::ParameterSet &pset)

void	rotateEvtPlane (HepMC::GenEvent *evt, double angle)

Private Attributes
double	abeamtarget_
	beam/target atomic mass number More...

unsigned int	angularspecselector_

double	bfixed_
	fixed impact param (fm); valid only if cflag_=0 More...

double	bmax_
	max impact param (fm); valid only if cflag_!=0 More...

double	bmin_
	min impact param (fm); valid only if cflag_!=0 More...

int	cflag_
	centrality flag =0 fixed impact param, <>0 minbias More...

double	comenergy
	collision energy More...

bool	docollisionalenloss_
	DEFAULT = true. More...

bool	doIsospin_
	Run n&p with proper ratios; if false, only p+p collisions. More...

bool	doquench_
	if true perform quenching (default = true) More...

bool	doradiativeenloss_
	DEFAULT = true. More...

bool	embedding_

double	evtPlane_

std::string	filterType_

HepMC::FourVector *	fVertex_
	Event signal vertex. More...

unsigned int	maxEventsToPrint_
	Events to print if verbosity. More...

unsigned int	nquarkflavor_

double	pfrac_
	Proton fraction in the nucleus. More...

int	protonSide_

edm::ParameterSet	pset_

Pythia6Service *	pythia6Service_

bool	pythiaHepMCVerbosity_
	HepMC verbosity flag. More...

unsigned int	pythiaPylistVerbosity_
	Pythia PYLIST Verbosity flag. More...

double	qgpt0_

double	qgptau0_

BaseHiGenEvtSelector *	selector_

std::vector< double >	signalVtx_
	Pset double vector to set event signal vertex. More...

edm::EDGetTokenT < CrossingFrame < edm::HepMCProduct > >	src_

Static Private Attributes
static const std::vector < std::string >	theSharedResources

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::BaseHadronizer
std::string	lheFile_

int	randomIndex_

Detailed Description

Definition at line 35 of file PyquenHadronizer.h.

Constructor & Destructor Documentation

PyquenHadronizer::PyquenHadronizer	(	const edm::ParameterSet &	pset,
		edm::ConsumesCollector &&	iC
	)

Definition at line 32 of file PyquenHadronizer.cc.

References cflag_, embedding_, edm::ParameterSet::exists(), filterType_, fVertex_, HiGenEvtSelectorFactory::get(), edm::ParameterSet::getUntrackedParameter(), HLT_FULL_cff::InputTag, LogDebug, maxEventsToPrint_, PYQVER, pythiaHepMCVerbosity_, pythiaPylistVerbosity_, selector_, signalVtx_, and src_.

     : BaseHadronizer(pset),
       pset_(pset),
       abeamtarget_(pset.getParameter<double>("aBeamTarget")),
       angularspecselector_(pset.getParameter<int>("angularSpectrumSelector")),
       bmin_(pset.getParameter<double>("bMin")),
       bmax_(pset.getParameter<double>("bMax")),
       bfixed_(pset.getParameter<double>("bFixed")),
       cflag_(pset.getParameter<int>("cFlag")),
       comenergy(pset.getParameter<double>("comEnergy")),
       doquench_(pset.getParameter<bool>("doQuench")),
       doradiativeenloss_(pset.getParameter<bool>("doRadiativeEnLoss")),
       docollisionalenloss_(pset.getParameter<bool>("doCollisionalEnLoss")),
       doIsospin_(pset.getParameter<bool>("doIsospin")),
       protonSide_(pset.getUntrackedParameter<int>("protonSide", 0)),
       embedding_(pset.getParameter<bool>("embeddingMode")),
       evtPlane_(0),
       nquarkflavor_(pset.getParameter<int>("qgpNumQuarkFlavor")),
       qgpt0_(pset.getParameter<double>("qgpInitialTemperature")),
       qgptau0_(pset.getParameter<double>("qgpProperTimeFormation")),
       maxEventsToPrint_(pset.getUntrackedParameter<int>("maxEventsToPrint", 1)),
       fVertex_(nullptr),
       pythiaHepMCVerbosity_(pset.getUntrackedParameter<bool>("pythiaHepMCVerbosity", false)),
       pythiaPylistVerbosity_(pset.getUntrackedParameter<int>("pythiaPylistVerbosity", 0)),
       pythia6Service_(new Pythia6Service(pset)),
       filterType_(pset.getUntrackedParameter<string>("filterType", "None")) {
   if (pset.exists("signalVtx"))
     signalVtx_ = pset.getUntrackedParameter<std::vector<double> >("signalVtx");
 
   if (signalVtx_.size() == 4) {
     if (!fVertex_)
       fVertex_ = new HepMC::FourVector();
     LogDebug("EventSignalVertex") << "Setting event signal vertex "
                                   << " x = " << signalVtx_.at(0) << " y = " << signalVtx_.at(1)
                                   << "  z= " << signalVtx_.at(2) << " t = " << signalVtx_.at(3) << endl;
     fVertex_->set(signalVtx_.at(0), signalVtx_.at(1), signalVtx_.at(2), signalVtx_.at(3));
   }
 
   // Verbosity Level
   // Valid PYLIST arguments are: 1, 2, 3, 5, 7, 11, 12, 13
   LogDebug("PYLISTverbosity") << "Pythia PYLIST verbosity level = " << pythiaPylistVerbosity_ << endl;
   // HepMC event verbosity Level
   pythiaHepMCVerbosity_ = pset.getUntrackedParameter<bool>("pythiaHepMCVerbosity", false);
   LogDebug("HepMCverbosity") << "Pythia HepMC verbosity = " << pythiaHepMCVerbosity_ << endl;
 
   //Max number of events printed on verbosity level
   maxEventsToPrint_ = pset.getUntrackedParameter<int>("maxEventsToPrint", 0);
   LogDebug("Events2Print") << "Number of events to be printed = " << maxEventsToPrint_ << endl;
 
   if (embedding_) {
     cflag_ = 0;
     src_ = iC.consumes<CrossingFrame<edm::HepMCProduct> >(
         pset.getUntrackedParameter<edm::InputTag>("backgroundLabel", edm::InputTag("mix", "generatorSmeared")));
   }
   selector_ = HiGenEvtSelectorFactory::get(filterType_, pset);
 
   int cm = 1, va, vb, vc;
   PYQVER(cm, va, vb, vc);
   //HepMC::HEPEVT_Wrapper::set_max_number_entries(4000);
 }

PyquenHadronizer::~PyquenHadronizer ( )

override

Definition at line 94 of file PyquenHadronizer.cc.

References pythia6Service_.

                                     {
   // distructor
   call_pystat(1);
 
   delete pythia6Service_;
 }

Member Function Documentation

void PyquenHadronizer::add_heavy_ion_rec ( HepMC::GenEvent * evt )

private

Definition at line 105 of file PyquenHadronizer.cc.

References evtPlane_, and plfpar.

Referenced by generatePartonsAndHadronize().

                                                            {
   HepMC::HeavyIon* hi = new HepMC::HeavyIon(1,            // Ncoll_hard
                                             -1,           // Npart_proj
                                             -1,           // Npart_targ
                                             1,            // Ncoll
                                             -1,           // spectator_neutrons
                                             -1,           // spectator_protons
                                             -1,           // N_Nwounded_collisions
                                             -1,           // Nwounded_N_collisions
                                             -1,           // Nwounded_Nwounded_collisions
                                             plfpar.bgen,  // impact_parameter in [fm]
                                             evtPlane_,    // event_plane_angle
                                             0,            // eccentricity
                                             -1            // sigma_inel_NN
   );
 
   evt->set_heavy_ion(*hi);
 
   delete hi;
 }

const char * PyquenHadronizer::classname ( ) const

Definition at line 374 of file PyquenHadronizer.cc.

374 { return "gen::PyquenHadronizer"; }

bool PyquenHadronizer::decay ( )

Definition at line 366 of file PyquenHadronizer.cc.

366 { return true; }

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

inline

Definition at line 48 of file PyquenHadronizer.h.

48 { return true; }

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

Definition at line 349 of file PyquenHadronizer.cc.

References gen::call_pygive(), gather_cfg::cout, mps_fire::i, and gen::pycomp_().

                                                                         {
   std::vector<int> pdg = _pdg;
   for (size_t i = 0; i < pdg.size(); i++) {
     int pyCode = pycomp_(pdg[i]);
     std::ostringstream pyCard;
     pyCard << "MDCY(" << pyCode << ",1)=0";
     std::cout << pyCard.str() << std::endl;
     call_pygive(pyCard.str());
   }
 
   return true;
 }

void PyquenHadronizer::doSetRandomEngine ( CLHEP::HepRandomEngine * v )

overrideprivatevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 102 of file PyquenHadronizer.cc.

References pythia6Service_, and gen::Pythia6Service::setRandomEngine().

102 { pythia6Service_->setRandomEngine(v); }

gen::v

double v[5][pyjets_maxn]

Definition: Cascade2Hadronizer.cc:76

gen::PyquenHadronizer::pythia6Service_

Pythia6Service * pythia6Service_

Definition: PyquenHadronizer.h:103

gen::Pythia6Service::setRandomEngine

void setRandomEngine(CLHEP::HepRandomEngine *v)

Definition: Pythia6Service.h:46

std::vector<std::string> const& gen::PyquenHadronizer::doSharedResources ( ) const

inlineoverrideprivatevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 56 of file PyquenHadronizer.h.

References theSharedResources.

56 { return theSharedResources; }

gen::PyquenHadronizer::theSharedResources

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

Definition: PyquenHadronizer.h:58

void PyquenHadronizer::finalizeEvent ( )

Definition at line 370 of file PyquenHadronizer.cc.

370 {}

bool PyquenHadronizer::generatePartonsAndHadronize ( )

Definition at line 127 of file PyquenHadronizer.cc.

References abeamtarget_, add_heavy_ion_rec(), bfixed_, bmax_, bmin_, cflag_, comenergy, gather_cfg::cout, doIsospin_, doquench_, alignCSCRings::e, embedding_, gen::BaseHadronizer::event(), evtPlane_, Exception, fVertex_, edm::Event::getByToken(), gen::BaseHadronizer::getEDMEvent(), edm::HepMCProduct::GetEvent(), edm::HepMCProduct::isVtxGenApplied(), reco_application_tbsim_DetSim-Digi_cfg::mix, nucleon(), edm::Handle< T >::product(), protonSide_, gen::pyexec_(), pypars, PYQUEN, pyquen_hepevtio, pythia6Service_, rotateEvtPlane(), and src_.

                                                    {
   Pythia6Service::InstanceWrapper guard(pythia6Service_);
 
   // Not possible to retrieve impact paramter and event plane info
   // at this part, need to overwrite filter() in
   // PyquenGeneratorFilter
 
   if (embedding_) {
     const edm::Event& e = getEDMEvent();
     HepMC::GenVertex* genvtx = nullptr;
     const HepMC::GenEvent* inev = nullptr;
     Handle<CrossingFrame<HepMCProduct> > cf;
     e.getByToken(src_, cf);
     MixCollection<HepMCProduct> mix(cf.product());
     if (mix.size() < 1) {
       throw cms::Exception("MatchVtx") << "Mixing has " << mix.size() << " sub-events, should have been at least 1"
                                        << endl;
     }
     const HepMCProduct& bkg = mix.getObject(0);
     if (!(bkg.isVtxGenApplied())) {
       throw cms::Exception("MatchVtx") << "Input background does not have smeared vertex!" << endl;
     } else {
       inev = bkg.GetEvent();
     }
 
     genvtx = inev->signal_process_vertex();
 
     if (!genvtx)
       throw cms::Exception("MatchVtx") << "Input background does not have signal process vertex!" << endl;
 
     double aX, aY, aZ, aT;
 
     aX = genvtx->position().x();
     aY = genvtx->position().y();
     aZ = genvtx->position().z();
     aT = genvtx->position().t();
 
     if (!fVertex_) {
       fVertex_ = new HepMC::FourVector();
     }
 
     //LogInfo("MatchVtx")
     std::cout << " setting vertex "
               << " aX " << aX << " aY " << aY << " aZ " << aZ << " aT " << aT << endl;
     fVertex_->set(aX, aY, aZ, aT);
 
     const HepMC::HeavyIon* hi = inev->heavy_ion();
 
     if (hi) {
       bfixed_ = hi->impact_parameter();
       evtPlane_ = hi->event_plane_angle();
     } else {
       LogWarning("EventEmbedding") << "Background event does not have heavy ion record!";
     }
   }
 
   // Generate PYQUEN event
   // generate single partonic PYTHIA jet event
 
   // Take into account whether it's a nn or pp or pn interaction
   if (doIsospin_) {
     string projN = "p";
     string targN = "p";
     if (protonSide_ != 1)
       projN = nucleon();
     if (protonSide_ != 2)
       targN = nucleon();
     call_pyinit("CMS", projN.data(), targN.data(), comenergy);
   }
   call_pyevnt();
 
   // call PYQUEN to apply parton rescattering and energy loss
   // if doQuench=FALSE, it is pure PYTHIA
   if (doquench_) {
     PYQUEN(abeamtarget_, cflag_, bfixed_, bmin_, bmax_);
     edm::LogInfo("PYQUENinAction") << "##### Calling PYQUEN(" << abeamtarget_ << "," << cflag_ << "," << bfixed_
                                    << ") ####";
   } else {
     edm::LogInfo("PYQUENinAction") << "##### Calling PYQUEN: QUENCHING OFF!! This is just PYTHIA !!!! ####";
   }
 
   // call PYTHIA to finish the hadronization
   pyexec_();
 
   // fill the HEPEVT with the PYJETS event record
   call_pyhepc(1);
 
   // event information
   // pyquen_hepevtio.set_trust_mothers_before_daughters(true);
   HepMC::GenEvent* evt = pyquen_hepevtio.read_next_event();
 
   evt->set_signal_process_id(pypars.msti[0]);  // type of the process
   evt->set_event_scale(pypars.pari[16]);       // Q^2
 
   if (embedding_)
     rotateEvtPlane(evt, evtPlane_);
   add_heavy_ion_rec(evt);
 
   if (fVertex_) {
     // Copy the HepMC::GenEvent
     std::unique_ptr<edm::HepMCProduct> HepMCEvt(new edm::HepMCProduct(evt));
 
     HepMCEvt->applyVtxGen(fVertex_);
     evt = new HepMC::GenEvent((*HepMCEvt->GetEvent()));
   }
 
   //  HepMC::HEPEVT_Wrapper::check_hepevt_consistency();
 
   event().reset(evt);
 
   return true;
 }

bool PyquenHadronizer::hadronize ( )

Definition at line 364 of file PyquenHadronizer.cc.

364 { return false; }

bool gen::PyquenHadronizer::initializeForExternalPartons ( )

bool PyquenHadronizer::initializeForInternalPartons ( )

Definition at line 257 of file PyquenHadronizer.cc.

References comenergy, and pythia6Service_.

                                                     {
   Pythia6Service::InstanceWrapper guard(pythia6Service_);
 
   // Call PYTHIA
   call_pyinit("CMS", "p", "p", comenergy);
 
   return true;
 }

const char * PyquenHadronizer::nucleon ( )

private

Definition at line 308 of file PyquenHadronizer.cc.

References pfrac_, and gen::pyr_().

Referenced by generatePartonsAndHadronize().

                                       {
   int* dummy = nullptr;
   double random = gen::pyr_(dummy);
   const char* nuc = nullptr;
   if (random > pfrac_)
     nuc = "n";
   else
     nuc = "p";
 
   return nuc;
 }

bool PyquenHadronizer::pyqpythia_init ( const edm::ParameterSet & pset )

private

Definition at line 267 of file PyquenHadronizer.cc.

References gen::call_pygive().

Referenced by readSettings().

                                                               {
   //Turn Hadronization Off whether or not there is quenching
   // PYEXEC is called later anyway
   string sHadOff("MSTP(111)=0");
   gen::call_pygive(sHadOff);
 
   return true;
 }

bool PyquenHadronizer::pyquen_init ( const edm::ParameterSet & pset )

private

Definition at line 277 of file PyquenHadronizer.cc.

References angularspecselector_, docollisionalenloss_, doradiativeenloss_, nquarkflavor_, pyqpar, qgpt0_, and qgptau0_.

Referenced by readSettings().

                                                            {
   // PYQUEN initialization
 
   // angular emitted gluon  spectrum selection
   pyqpar.ianglu = angularspecselector_;
 
   // type of medium induced partonic energy loss
   if (doradiativeenloss_ && docollisionalenloss_) {
     edm::LogInfo("PYQUENinEnLoss") << "##### PYQUEN: Radiative AND Collisional partonic energy loss ON ####";
     pyqpar.ienglu = 0;
   } else if (doradiativeenloss_) {
     edm::LogInfo("PYQUENinRad") << "##### PYQUEN: Only RADIATIVE partonic energy loss ON ####";
     pyqpar.ienglu = 1;
   } else if (docollisionalenloss_) {
     edm::LogInfo("PYQUENinColl") << "##### PYQUEN: Only COLLISIONAL partonic energy loss ON ####";
     pyqpar.ienglu = 2;
   } else {
     edm::LogInfo("PYQUENinEnLoss") << "##### PYQUEN: Radiative AND Collisional partonic energy loss ON ####";
     pyqpar.ienglu = 0;
   }
 
   // number of active quark flavors in qgp
   pyqpar.nfu = nquarkflavor_;
   // initial temperature of QGP
   pyqpar.T0u = qgpt0_;
   // proper time of QGP formation
   pyqpar.tau0u = qgptau0_;
 
   return true;
 }

bool PyquenHadronizer::readSettings ( int )

Definition at line 240 of file PyquenHadronizer.cc.

References abeamtarget_, pfrac_, funct::pow(), pset_, pyqpythia_init(), pyquen_init(), pythia6Service_, gen::Pythia6Service::setCSAParams(), and gen::Pythia6Service::setGeneralParams().

                                        {
   Pythia6Service::InstanceWrapper guard(pythia6Service_);
   pythia6Service_->setGeneralParams();
   pythia6Service_->setCSAParams();
 
   //Proton to Nucleon fraction
   pfrac_ = 1. / (1.98 + 0.015 * pow(abeamtarget_, 2. / 3));
 
   //initialize pythia
   pyqpythia_init(pset_);
 
   //initilize pyquen
   pyquen_init(pset_);
 
   return true;
 }

bool PyquenHadronizer::residualDecay ( )

Definition at line 368 of file PyquenHadronizer.cc.

368 { return true; }

void PyquenHadronizer::rotateEvtPlane	(	HepMC::GenEvent *	evt,
		double	angle
	)

private

Definition at line 320 of file PyquenHadronizer.cc.

References funct::cos(), funct::sin(), and submitPVValidationJobs::t.

Referenced by generatePartonsAndHadronize().

                                                                       {
   double sinphi0 = sin(angle);
   double cosphi0 = cos(angle);
 
   for (HepMC::GenEvent::vertex_iterator vt = evt->vertices_begin(); vt != evt->vertices_end(); ++vt) {
     double x0 = (*vt)->position().x();
     double y0 = (*vt)->position().y();
     double z = (*vt)->position().z();
     double t = (*vt)->position().t();
 
     double x = x0 * cosphi0 - y0 * sinphi0;
     double y = y0 * cosphi0 + x0 * sinphi0;
 
     (*vt)->set_position(HepMC::FourVector(x, y, z, t));
   }
 
   for (HepMC::GenEvent::particle_iterator vt = evt->particles_begin(); vt != evt->particles_end(); ++vt) {
     double x0 = (*vt)->momentum().x();
     double y0 = (*vt)->momentum().y();
     double z = (*vt)->momentum().z();
     double t = (*vt)->momentum().t();
 
     double x = x0 * cosphi0 - y0 * sinphi0;
     double y = y0 * cosphi0 + x0 * sinphi0;
 
     (*vt)->set_momentum(HepMC::FourVector(x, y, z, t));
   }
 }

bool gen::PyquenHadronizer::select ( HepMC::GenEvent * evtTry ) const

inlineoverridevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 49 of file PyquenHadronizer.h.

References BaseHiGenEvtSelector::filter(), and selector_.

49 { return selector_->filter(evtTry); }

BaseHiGenEvtSelector::filter

virtual bool filter(HepMC::GenEvent *)

Definition: BaseHiGenEvtSelector.h:12

gen::PyquenHadronizer::selector_

BaseHiGenEvtSelector * selector_

Definition: PyquenHadronizer.h:105

void PyquenHadronizer::statistics ( )

Definition at line 372 of file PyquenHadronizer.cc.

372 {}

Member Data Documentation

double gen::PyquenHadronizer::abeamtarget_

private

beam/target atomic mass number

Definition at line 68 of file PyquenHadronizer.h.

Referenced by generatePartonsAndHadronize(), and readSettings().

unsigned int gen::PyquenHadronizer::angularspecselector_

private

angular emitted gluon spectrum selection DEFAULT= 0 – small angular emitted gluon spectrum = 1 – broad angular emitted gluon spectrum = 2 – collinear angular emitted gluon spectrum

Definition at line 69 of file PyquenHadronizer.h.

Referenced by pyquen_init().

double gen::PyquenHadronizer::bfixed_

private

fixed impact param (fm); valid only if cflag_=0

Definition at line 75 of file PyquenHadronizer.h.

Referenced by generatePartonsAndHadronize().

double gen::PyquenHadronizer::bmax_

private

max impact param (fm); valid only if cflag_!=0

Definition at line 74 of file PyquenHadronizer.h.

Referenced by generatePartonsAndHadronize().