PyquenHadronizer.cc

Go to the documentation of this file.

/*
 *
 * Generates PYQUEN HepMC events
 *
*/
 
#include <iostream>
#include <ctime>
 
#include "GeneratorInterface/PyquenInterface/interface/PyquenHadronizer.h"
 
#include "GeneratorInterface/Core/interface/FortranInstance.h"
#include "GeneratorInterface/PyquenInterface/interface/PyquenWrapper.h"
#include "GeneratorInterface/Pythia6Interface/interface/Pythia6Declarations.h"
#include "GeneratorInterface/Pythia6Interface/interface/Pythia6Service.h"
 
#include "SimDataFormats/GeneratorProducts/interface/GenEventInfoProduct.h"
 
#include "SimDataFormats/GeneratorProducts/interface/HepMCProduct.h"
#include "FWCore/Concurrency/interface/SharedResourceNames.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
#include "GeneratorInterface/HiGenCommon/interface/HiGenEvtSelectorFactory.h"
 
#include "HepMC/IO_HEPEVT.h"
#include "HepMC/PythiaWrapper.h"
 
using namespace gen;
using namespace edm;
using namespace std;
 
HepMC::IO_HEPEVT hepevtio;
 
const std::vector<std::string> PyquenHadronizer::theSharedResources = {edm::SharedResourceNames::kPythia6,
                                                                       gen::FortranInstance::kFortranInstance};
 
PyquenHadronizer ::PyquenHadronizer(const ParameterSet& pset)
    : 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() {
  // distructor
  call_pystat(1);
 
  delete pythia6Service_;
}
 
//_____________________________________________________________________
void PyquenHadronizer::doSetRandomEngine(CLHEP::HepRandomEngine* v) { pythia6Service_->setRandomEngine(v); }
 
//_____________________________________________________________________
void PyquenHadronizer::add_heavy_ion_rec(HepMC::GenEvent* evt) {
  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;
}
 
//_____________________________________________________________________
bool PyquenHadronizer::generatePartonsAndHadronize() {
  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::readSettings(int) {
  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::initializeForInternalPartons() {
  Pythia6Service::InstanceWrapper guard(pythia6Service_);
 
  // Call PYTHIA
  call_pyinit("CMS", "p", "p", comenergy);
 
  return true;
}
 
//_____________________________________________________________________
bool PyquenHadronizer::pyqpythia_init(const ParameterSet& pset) {
  //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 ParameterSet& pset) {
  // 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;
}
 
const char* PyquenHadronizer::nucleon() {
  int* dummy = nullptr;
  double random = gen::pyr_(dummy);
  const char* nuc = nullptr;
  if (random > pfrac_)
    nuc = "n";
  else
    nuc = "p";
 
  return nuc;
}
 
void PyquenHadronizer::rotateEvtPlane(HepMC::GenEvent* evt, double angle) {
  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 PyquenHadronizer::declareStableParticles(const std::vector<int>& _pdg) {
  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;
}
 
//____________________________________________________________________
 
bool PyquenHadronizer::hadronize() { return false; }
 
bool PyquenHadronizer::decay() { return true; }
 
bool PyquenHadronizer::residualDecay() { return true; }
 
void PyquenHadronizer::finalizeEvent() {}
 
void PyquenHadronizer::statistics() {}
 
const char* PyquenHadronizer::classname() const { return "gen::PyquenHadronizer"; }