#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 &)

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

unsigned int	angularspecselector_
	beam/target atomic mass number More...

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

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

double	bmin_

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

double	comenergy
	centrality flag =0 fixed impact param, <>0 minbias More...

bool	docollisionalenloss_
	DEFAULT = true. More...

bool	doIsospin_
	DEFAULT = true. More...

bool	doquench_
	collision energy More...

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

bool	embedding_

double	evtPlane_

std::string	filterType_

unsigned int	maxEventsToPrint_

unsigned int	nquarkflavor_
	Proton fraction in the nucleus. More...

double	pfrac_

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

edm::ParameterSet	pset_

Pythia6Service *	pythia6Service_

bool	pythiaHepMCVerbosity_
	Events to print if verbosity. More...

unsigned int	pythiaPylistVerbosity_
	HepMC verbosity flag. More...

double	qgpt0_

double	qgptau0_

BaseHiGenEvtSelector *	selector_

edm::InputTag	src_
	Pythia PYLIST Verbosity flag. More...

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 30 of file PyquenHadronizer.h.

Constructor & Destructor Documentation

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

Definition at line 38 of file PyquenHadronizer.cc.

References cflag_, embedding_, filterType_, HiGenEvtSelectorFactory::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), LogDebug, maxEventsToPrint_, PYQVER, pythiaHepMCVerbosity_, pythiaPylistVerbosity_, selector_, 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)),
       pythiaHepMCVerbosity_(pset.getUntrackedParameter<bool>("pythiaHepMCVerbosity", false)),
       pythiaPylistVerbosity_(pset.getUntrackedParameter<int>("pythiaPylistVerbosity", 0)),
       pythia6Service_(new Pythia6Service(pset)),
       filterType_(pset.getUntrackedParameter<string>("filterType", "None")) {
   // 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_ = pset.getParameter<InputTag>("backgroundLabel");
   }
   selector_ = HiGenEvtSelectorFactory::get(filterType_, pset);
 
   int cm = 1, va, vb, vc;
   PYQVER(cm, va, vb, vc);
 }

PyquenHadronizer::~PyquenHadronizer ( )

override

Definition at line 85 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 96 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 323 of file PyquenHadronizer.cc.

323 { return "gen::PyquenHadronizer"; }

bool PyquenHadronizer::decay ( )

Definition at line 315 of file PyquenHadronizer.cc.

315 { return true; }

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

inline

Definition at line 43 of file PyquenHadronizer.h.

43 { return true; }

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

Definition at line 298 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 93 of file PyquenHadronizer.cc.

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

93 { pythia6Service_->setRandomEngine(v); }

gen::v

double v[5][pyjets_maxn]

Definition: Cascade2Hadronizer.cc:74

gen::PyquenHadronizer::pythia6Service_

Pythia6Service * pythia6Service_

Definition: PyquenHadronizer.h:94

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 51 of file PyquenHadronizer.h.

51 { return theSharedResources; }

gen::PyquenHadronizer::theSharedResources

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

Definition: PyquenHadronizer.h:53

void PyquenHadronizer::finalizeEvent ( )

Definition at line 319 of file PyquenHadronizer.cc.

319 {}

bool PyquenHadronizer::generatePartonsAndHadronize ( )

Definition at line 118 of file PyquenHadronizer.cc.

References abeamtarget_, add_heavy_ion_rec(), bfixed_, bmax_, bmin_, cflag_, comenergy, doIsospin_, doquench_, MillePedeFileConverter_cfg::e, embedding_, gen::BaseHadronizer::event(), evtPlane_, edm::Event::getByLabel(), gen::BaseHadronizer::getEDMEvent(), edm::HepMCProduct::GetEvent(), hepevtio, input, nucleon(), protonSide_, gen::pyexec_(), pypars, PYQUEN, 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
 
   const edm::Event& e = getEDMEvent();
 
   if (embedding_) {
     Handle<HepMCProduct> input;
     e.getByLabel(src_, input);
     const HepMC::GenEvent* inev = input->GetEvent();
     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
   HepMC::GenEvent* evt = 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);
 
   HepMC::HEPEVT_Wrapper::check_hepevt_consistency();
   //std::cout<<"Entries number: "<<HepMC::HEPEVT_Wrapper::number_entries() <<" Max. entries "<<HepMC::HEPEVT_Wrapper::max_number_entries()<<std::endl;
 
   event().reset(evt);
 
   return true;
 }

bool PyquenHadronizer::hadronize ( )

Definition at line 313 of file PyquenHadronizer.cc.

313 { return false; }

bool gen::PyquenHadronizer::initializeForExternalPartons ( )

bool PyquenHadronizer::initializeForInternalPartons ( )

Definition at line 206 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 257 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 216 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 226 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 189 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 317 of file PyquenHadronizer.cc.

317 { return true; }

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

private

Definition at line 269 of file PyquenHadronizer.cc.

References funct::cos(), funct::sin(), and OrderedSet::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 44 of file PyquenHadronizer.h.

References data-class-funcs::classname, myMessageLogger_cff::statistics, and findQualityFiles::v.

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

BaseHiGenEvtSelector::filter

virtual bool filter(HepMC::GenEvent *)

Definition: BaseHiGenEvtSelector.h:12

gen::PyquenHadronizer::selector_

BaseHiGenEvtSelector * selector_

Definition: PyquenHadronizer.h:96

void PyquenHadronizer::statistics ( )

Definition at line 321 of file PyquenHadronizer.cc.

321 {}

Member Data Documentation

double gen::PyquenHadronizer::abeamtarget_

private

Definition at line 63 of file PyquenHadronizer.h.

Referenced by generatePartonsAndHadronize(), and readSettings().

unsigned int gen::PyquenHadronizer::angularspecselector_

private

beam/target atomic mass number

Definition at line 64 of file PyquenHadronizer.h.

Referenced by pyquen_init().

double gen::PyquenHadronizer::bfixed_

private

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

Definition at line 70 of file PyquenHadronizer.h.

Referenced by generatePartonsAndHadronize().

double gen::PyquenHadronizer::bmax_

private

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

Definition at line 69 of file PyquenHadronizer.h.

Referenced by generatePartonsAndHadronize().

double gen::PyquenHadronizer::bmin_

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 68 of file PyquenHadronizer.h.

Referenced by generatePartonsAndHadronize().

int gen::PyquenHadronizer::cflag_

private

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

Definition at line 71 of file PyquenHadronizer.h.

Referenced by generatePartonsAndHadronize(), and PyquenHadronizer().

double gen::PyquenHadronizer::comenergy

private

centrality flag =0 fixed impact param, <>0 minbias

Definition at line 72 of file PyquenHadronizer.h.

Referenced by generatePartonsAndHadronize(), and initializeForInternalPartons().