#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	residualDecay ()
void	statistics ()
virtual	~PyquenHadronizer ()
Private Member Functions
void	add_heavy_ion_rec (HepMC::GenEvent *evt)
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
double	bfixed_
	max impact param (fm); valid only if cflag_!=0
double	bmax_
	min impact param (fm); valid only if cflag_!=0
double	bmin_
int	cflag_
	fixed impact param (fm); valid only if cflag_=0
double	comenergy
	centrality flag =0 fixed impact param, <>0 minbias
bool	docollisionalenloss_
	DEFAULT = true.
bool	doIsospin_
	DEFAULT = true.
bool	doquench_
	collision energy
bool	doradiativeenloss_
	if true perform quenching (default = true)
bool	embedding_
	Run n&p with proper ratios; if false, only p+p collisions.
double	evtPlane_
std::string	filterType_
unsigned int	maxEventsToPrint_
int	maxTries_
unsigned int	nquarkflavor_
	Proton fraction in the nucleus.
double	pfrac_
edm::ParameterSet	pset_
Pythia6Service *	pythia6Service_
bool	pythiaHepMCVerbosity_
	Events to print if verbosity.
unsigned int	pythiaPylistVerbosity_
	HepMC verbosity flag.
double	qgpt0_
double	qgptau0_
BaseHiGenEvtSelector *	selector_
edm::InputTag	src_
	Pythia PYLIST Verbosity flag.

Detailed Description

Definition at line 25 of file PyquenHadronizer.h.

Constructor & Destructor Documentation

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

Definition at line 35 of file PyquenHadronizer.cc.

References cflag_, embedding_, filterType_, reco::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), LogDebug, maxEventsToPrint_, 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")),
embedding_(pset.getParameter<bool>("embeddingMode")),
evtPlane_(0),
filterType_(pset.getUntrackedParameter<string>("filterType","None")),
maxTries_(pset.getUntrackedParameter<int>("maxTries",1000)),
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))
{
  // 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);
}

PyquenHadronizer::~PyquenHadronizer ( ) [virtual]

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

{
   return "gen::PyquenHadronizer";
}

bool PyquenHadronizer::decay ( )

Definition at line 323 of file PyquenHadronizer.cc.

{
   return true;
}

bool gen::PyquenHadronizer::declareSpecialSettings ( const std::vector< std::string > ) [inline]

Definition at line 38 of file PyquenHadronizer.h.

{ return true; }

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

Definition at line 299 of file PyquenHadronizer.cc.

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

{
   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::finalizeEvent ( )

Definition at line 333 of file PyquenHadronizer.cc.

                                    {

}

bool PyquenHadronizer::generatePartonsAndHadronize ( )

Definition at line 117 of file PyquenHadronizer.cc.

References abeamtarget_, add_heavy_ion_rec(), bfixed_, bmax_, bmin_, cflag_, comenergy, edm::errors::Configuration, cmsDriverOptions::counter, doIsospin_, doquench_, embedding_, gen::BaseHadronizer::event(), evtPlane_, Exception, BaseHiGenEvtSelector::filter(), filterType_, edm::Event::getByLabel(), gen::BaseHadronizer::getEDMEvent(), hepevtio, collect_tpl::input, maxTries_, nucleon(), gen::pyexec_(), pypars, PYQUEN, pythia6Service_, rotateEvtPlane(), selector_, 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!";
      }
   }

   int counter = 0;
   bool pass = false;

   HepMC::GenEvent* evt = 0;
   while(!pass){
      if(counter == maxTries_) throw edm::Exception(edm::errors::Configuration,"InfiniteLoop")<<"Pyquen tried "<<counter<<" times to generate event with "<<filterType_.data()<<" ."<<endl;
      
      // Generate PYQUEN event
      // generate single partonic PYTHIA jet event

      // Take into account whether it's a nn or pp or pn interaction
      if(doIsospin_) call_pyinit("CMS", nucleon(), nucleon(), 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
      evt = hepevtio.read_next_event();
      pass = selector_->filter(evt);
      counter++;
   }

   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);
   
   event().reset(evt);

  return true;
}

bool PyquenHadronizer::hadronize ( )

Definition at line 318 of file PyquenHadronizer.cc.

{
   return false;
}

bool gen::PyquenHadronizer::initializeForExternalPartons ( )

bool PyquenHadronizer::initializeForInternalPartons ( )

Definition at line 186 of file PyquenHadronizer.cc.

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

                                                   {

   Pythia6Service::InstanceWrapper guard(pythia6Service_);
   pythia6Service_->setGeneralParams();

   //Proton to Nucleon fraction
   pfrac_ = 1./(1.98+0.015*pow(abeamtarget_,2./3));

   //initialize pythia         
   pyqpythia_init(pset_);

   //initilize pyquen          
   pyquen_init(pset_);

   // Call PYTHIA              
   call_pyinit("CMS", "p", "p", comenergy);

   return true;
}

const char * PyquenHadronizer::nucleon ( ) [private]

Definition at line 253 of file PyquenHadronizer.cc.

References pfrac_, gen::pyr_(), and random.

Referenced by generatePartonsAndHadronize().

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

bool PyquenHadronizer::pyqpythia_init ( const edm::ParameterSet & pset ) [private]

Definition at line 208 of file PyquenHadronizer.cc.

References gen::call_pygive(), and doquench_.

Referenced by initializeForInternalPartons().

{

   //Turn Hadronization Off if there is quenching  
   if(doquench_){
      string sHadOff("MSTP(111)=0");
      gen::call_pygive(sHadOff);
   }
  return true;
}

bool PyquenHadronizer::pyquen_init ( const edm::ParameterSet & pset ) [private]

Definition at line 221 of file PyquenHadronizer.cc.

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

Referenced by initializeForInternalPartons().

{
  // 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::residualDecay ( )

Definition at line 328 of file PyquenHadronizer.cc.

{
   return true;
}

void PyquenHadronizer::rotateEvtPlane	(	HepMC::GenEvent *	evt,
		double	angle
	)		`[private]`

Definition at line 263 of file PyquenHadronizer.cc.

References funct::cos(), funct::sin(), matplotRender::t, x, detailsBasic3DVector::y, and z.

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) ) ;
      }
}

void PyquenHadronizer::statistics ( )

Definition at line 337 of file PyquenHadronizer.cc.

{
}

Member Data Documentation

double gen::PyquenHadronizer::abeamtarget_ [private]

Definition at line 53 of file PyquenHadronizer.h.

Referenced by generatePartonsAndHadronize(), and initializeForInternalPartons().

unsigned int gen::PyquenHadronizer::angularspecselector_ [private]

beam/target atomic mass number

Definition at line 54 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 60 of file PyquenHadronizer.h.

Referenced by generatePartonsAndHadronize().

double gen::PyquenHadronizer::bmax_ [private]

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

Definition at line 59 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 58 of file PyquenHadronizer.h.

Referenced by generatePartonsAndHadronize().

int gen::PyquenHadronizer::cflag_ [private]

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

Definition at line 61 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 62 of file PyquenHadronizer.h.

Referenced by generatePartonsAndHadronize(), and initializeForInternalPartons().

bool gen::PyquenHadronizer::docollisionalenloss_ [private]

DEFAULT = true.