gen::Pythia6Service Class Reference

#include <Pythia6Service.h>

Inheritance diagram for gen::Pythia6Service:

Public Member Functions
void	closePYUPDA ()
void	closeSLHA ()
void	enter () override
void	openPYUPDA (const char *, bool write_file)
void	openSLHA (const char *)
	Pythia6Service ()
	Pythia6Service (edm::ParameterSet const &)
CLHEP::HepRandomEngine *	randomEngine () const
void	setCSAParams ()
void	setGeneralParams ()
void	setPYUPDAParams (bool afterPyinit)
void	setRandomEngine (CLHEP::HepRandomEngine *v)
void	setSLHAFromHeader (const std::vector< std::string > &lines)
void	setSLHAParams ()
	~Pythia6Service () override
Public Member Functions inherited from gen::FortranInstance
void	call (void(&fn)())
template<typename T >
T	call (T(&fn)())
template<typename A >
void	call (void(&fn)(A), A a)
template<typename T , typename A >
T	call (T(&fn)(A), A a)
template<typename A1 , typename A2 >
void	call (void(&fn)(A1, A2), A1 a1, A2 a2)
template<typename T , typename A1 , typename A2 >
T	call (T(&fn)(A1, A2), A1 a1, A2 a2)
	FortranInstance ()
virtual void	leave ()
virtual void	upEvnt ()
virtual void	upInit ()
virtual bool	upVeto ()
virtual	~FortranInstance () noexcept(false)

Private Attributes
bool	fInitialising
std::vector< std::string >	fParamCSA
std::vector< std::string >	fParamGeneral
std::vector< std::string >	fParamPYUPDA
std::vector< std::string >	fParamSLHA
CLHEP::HepRandomEngine *	fRandomEngine
int	fUnitPYUPDA
int	fUnitSLHA

Static Private Attributes
static Pythia6Service *	fPythia6Owner = nullptr

Friends
double	gen::pyr_ (int *)

Additional Inherited Members
Static Public Member Functions inherited from gen::FortranInstance
template<typename T >
static T *	getInstance ()
Static Public Attributes inherited from gen::FortranInstance
static const std::string	kFortranInstance = "FortranInstance"

Detailed Description

Definition at line 24 of file Pythia6Service.h.

Constructor & Destructor Documentation

Pythia6Service() [1/2]

Pythia6Service::Pythia6Service

(

)

Definition at line 72 of file Pythia6Service.cc.

: fRandomEngine(nullptr), fUnitSLHA(24), fUnitPYUPDA(25) {}

Pythia6Service() [2/2]

Pythia6Service::Pythia6Service

(

edm::ParameterSet const &

ps

)

Definition at line 74 of file Pythia6Service.cc.

References Exception, fParamCSA, fParamGeneral, fParamPYUPDA, fParamSLHA, fPythia6Owner, edm::ParameterSet::getParameter(), mps_splice::line, and groupFilesInBlocks::lines.

                                                     : fRandomEngine(nullptr), fUnitSLHA(24), fUnitPYUPDA(25) {
  if (fPythia6Owner)
    throw cms::Exception("PythiaError") << "Two Pythia6Service instances claiming Pythia6 ownership." << std::endl;

  fPythia6Owner = this;

  /*
   ParameterCollector collector(ps.getParameter<edm::ParameterSet>("PythiaParameters"));

   fParamGeneral.clear();
   fParamCSA.clear();
   fParamSLHA.clear();
   
   fParamGeneral = std::vector<std::string>(collector.begin(), collector.end());
   fParamCSA     = std::vector<std::string>(collector.begin("CSAParameters"), collector.end());
   fParamSLHA    = std::vector<std::string>(collector.begin("SLHAParameters"), collector.end());
*/

  // Set PYTHIA parameters in a single ParameterSet
  //
  edm::ParameterSet pythia_params = ps.getParameter<edm::ParameterSet>("PythiaParameters");

  // read and sort Pythia6 cards
  //
  std::vector<std::string> setNames = pythia_params.getParameter<std::vector<std::string> >("parameterSets");

  // std::vector<std::string>   paramLines;
  fParamGeneral.clear();
  fParamCSA.clear();
  fParamSLHA.clear();
  fParamPYUPDA.clear();

  for (std::vector<std::string>::const_iterator iter = setNames.begin(); iter != setNames.end(); ++iter) {
    std::vector<std::string> lines = pythia_params.getParameter<std::vector<std::string> >(*iter);

    for (std::vector<std::string>::const_iterator line = lines.begin(); line != lines.end(); ++line) {
      if (line->substr(0, 7) == "MRPY(1)")
        throw cms::Exception("PythiaError") << "Attempted to set random number"
                                               " using Pythia command 'MRPY(1)'."
                                               " Please use the"
                                               " RandomNumberGeneratorService."
                                            << std::endl;

      if (*iter == "CSAParameters") {
        fParamCSA.push_back(*line);
      } else if (*iter == "SLHAParameters") {
        fParamSLHA.push_back(*line);
      } else if (*iter == "PYUPDAParameters") {
        fParamPYUPDA.push_back(*line);
      } else {
        fParamGeneral.push_back(*line);
      }
    }
  }
}

~Pythia6Service()

Pythia6Service::~Pythia6Service ( )

override

Definition at line 130 of file Pythia6Service.cc.

References fParamCSA, fParamGeneral, fParamPYUPDA, fParamSLHA, and fPythia6Owner.

                                {
  if (fPythia6Owner == this)
    fPythia6Owner = nullptr;

  fParamGeneral.clear();
  fParamCSA.clear();
  fParamSLHA.clear();
  fParamPYUPDA.clear();
}

Member Function Documentation

closePYUPDA()

void Pythia6Service::closePYUPDA

(

)

Definition at line 232 of file Pythia6Service.cc.

References fiocls_(), and fUnitPYUPDA.

                                 {
  fiocls_(&fUnitPYUPDA);

  return;
}

closeSLHA()

void Pythia6Service::closeSLHA

(

)

Definition at line 226 of file Pythia6Service.cc.

References fiocls_(), and fUnitSLHA.

Referenced by gen::Pythia6Hadronizer::initializeForExternalPartons(), and gen::Pythia6Hadronizer::initializeForInternalPartons().

                               {
  fiocls_(&fUnitSLHA);

  return;
}

enter()

void Pythia6Service::enter ( )

overridevirtual

Reimplemented from gen::FortranInstance.

Definition at line 140 of file Pythia6Service.cc.

References gen::call_pygive(), gen::FortranInstance::enter(), and fPythia6Owner.

                           {
  FortranInstance::enter();

  if (!fPythia6Owner) {
    edm::LogInfo("Generator|Pythia6Interface") << "gen::Pythia6Service is going to initialise Pythia, as no other "
                                                  "instace has done so yet, and Pythia service routines have been "
                                                  "requested by a dummy instance."
                                               << std::endl;

    call_pygive("MSTU(12)=12345");
    call_pyinit("NONE", "", "", 0.0);

    fPythia6Owner = this;
  }
}

openPYUPDA()

void Pythia6Service::openPYUPDA	(	const char *	file,
		bool	write_file
	)

Definition at line 210 of file Pythia6Service.cc.

References call_pyupda(), gather_cfg::cout, geometryDiff::file, fioopn_(), fioopnw_(), and fUnitPYUPDA.

Referenced by setPYUPDAParams().

                                                                 {
  if (write_file) {
    std::cout << "=== WRITING PYUPDA FILE " << file << " ===" << std::endl;
    fioopnw_(&fUnitPYUPDA, file, strlen(file));
    // Write Pythia particle table to this card file.
    call_pyupda(1, fUnitPYUPDA);
  } else {
    std::cout << "=== READING PYUPDA FILE " << file << " ===" << std::endl;
    fioopn_(&fUnitPYUPDA, file, strlen(file));
    // Update Pythia particle table with this card file.
    call_pyupda(3, fUnitPYUPDA);
  }

  return;
}

openSLHA()

void Pythia6Service::openSLHA

(

const char *

file

)

Definition at line 197 of file Pythia6Service.cc.

References gen::call_pygive(), geometryDiff::file, fioopn_(), and fUnitSLHA.

Referenced by setSLHAFromHeader(), and setSLHAParams().

                                              {
  std::ostringstream pyCard1;
  pyCard1 << "IMSS(21)=" << fUnitSLHA;
  call_pygive(pyCard1.str());
  std::ostringstream pyCard2;
  pyCard2 << "IMSS(22)=" << fUnitSLHA;
  call_pygive(pyCard2.str());

  fioopn_(&fUnitSLHA, file, strlen(file));

  return;
}

randomEngine()

CLHEP::HepRandomEngine* gen::Pythia6Service::randomEngine ( ) const

inline

Definition at line 45 of file Pythia6Service.h.

References fRandomEngine.

Referenced by gen::Pythia6Gun::produce().

{ return fRandomEngine; }

setCSAParams()

void Pythia6Service::setCSAParams

(

)

Definition at line 167 of file Pythia6Service.cc.

References visDQMUpload::buf, fParamCSA, mps_fire::i, reco_skim_cfg_mod::maxSize, SETCSAPARBUFSIZE, gen::txgive_(), and gen::txgive_init_().

Referenced by gen::Pythia6Gun::beginLuminosityBlock(), gen::PyquenHadronizer::readSettings(), and gen::Pythia6Hadronizer::readSettings().

                                  {
#define SETCSAPARBUFSIZE 514
  char buf[SETCSAPARBUFSIZE];

  txgive_init_();
  for (std::vector<std::string>::const_iterator iter = fParamCSA.begin(); iter != fParamCSA.end(); ++iter) {
    // Null pad the string should not be needed because it uses
    // read, which will look for \n, but just in case...
    for (size_t i = 0; i < SETCSAPARBUFSIZE; ++i)
      buf[i] = ' ';
    // Skip empty parameters.
    if (iter->length() <= 0)
      continue;
    // Limit the size of the string to something which fits the buffer.
    size_t maxSize = iter->length() > (SETCSAPARBUFSIZE - 2) ? (SETCSAPARBUFSIZE - 2) : iter->length();
    strncpy(buf, iter->c_str(), maxSize);
    // Add extra \n if missing, otherwise "read" continues reading.
    if (buf[maxSize - 1] != '\n') {
      buf[maxSize] = '\n';
      // Null terminate in case the string is passed back to C.
      // Not sure that is actually needed.
      buf[maxSize + 1] = 0;
    }
    txgive_(buf, iter->length());
  }

  return;
#undef SETCSAPARBUFSIZE
}

setGeneralParams()

void Pythia6Service::setGeneralParams

(

)

Definition at line 156 of file Pythia6Service.cc.

References gen::call_pygive(), and fParamGeneral.

Referenced by gen::Pythia6Gun::beginLuminosityBlock(), gen::PyquenHadronizer::readSettings(), gen::ExhumeHadronizer::readSettings(), gen::Pythia6Hadronizer::readSettings(), gen::Hydjet2Hadronizer::readSettings(), and gen::HydjetHadronizer::readSettings().

                                      {
  // now pass general config cards
  //
  for (std::vector<std::string>::const_iterator iter = fParamGeneral.begin(); iter != fParamGeneral.end(); ++iter) {
    if (!call_pygive(*iter))
      throw cms::Exception("PythiaError") << "Pythia did not accept \"" << *iter << "\"." << std::endl;
  }

  return;
}

setPYUPDAParams()

void Pythia6Service::setPYUPDAParams

(

bool

afterPyinit

)

Definition at line 275 of file Pythia6Service.cc.

References mps_fire::end, DeadROC_duringRun::f1, geometryDiff::file, fParamPYUPDA, openPYUPDA(), AlCaHLTBitMon_QueryRunRegistry::string, and groupFilesInBlocks::temp.

Referenced by gen::Pythia6Hadronizer::initializeForExternalPartons(), and gen::Pythia6Hadronizer::initializeForInternalPartons().

                                                     {
  std::string shortfile;
  bool write_file = false;
  bool usePostPyinit = false;

  //   std::cout<<"=== CALLING setPYUPDAParams === "<<afterPyinit<<" "<<fParamPYUPDA.size()<<std::endl;

  // This assumes that PYUPDAFILE only appears once ...

  for (std::vector<std::string>::const_iterator iter = fParamPYUPDA.begin(); iter != fParamPYUPDA.end(); iter++) {
    //     std::cout<<"PYUPDA check "<<*iter<<std::endl;
    if (iter->find("PYUPDAFILE", 0) != std::string::npos) {
      std::string::size_type start = iter->find_first_of("=") + 1;
      std::string::size_type end = iter->length() - 1;
      std::string::size_type temp = iter->find_first_of("'", start);
      if (temp != std::string::npos) {
        start = temp + 1;
        end = iter->find_last_of("'") - 1;
      }
      start = iter->find_first_not_of(" ", start);
      end = iter->find_last_not_of(" ", end);
      //std::cout << " start, end = " << start << " " << end << std::endl;
      shortfile = iter->substr(start, end - start + 1);
    } else if (iter->find("PYUPDAWRITE", 0) != std::string::npos) {
      write_file = true;
    } else if (iter->find("PYUPDApostPYINIT", 0) != std::string::npos) {
      usePostPyinit = true;
    }
  }

  if (!shortfile.empty()) {
    std::string file;
    if (write_file) {
      file = shortfile;
    } else {
      // If reading, get full path to file and require it to exist.
      FileInPath f1(shortfile);
      file = f1.fullPath();
    }

    if (afterPyinit == usePostPyinit || (write_file && afterPyinit)) {
      openPYUPDA(file.c_str(), write_file);
    }
  }

  return;
}

setRandomEngine()

void gen::Pythia6Service::setRandomEngine ( CLHEP::HepRandomEngine *  v )

inline

Definition at line 46 of file Pythia6Service.h.

References fRandomEngine, and gen::v.

Referenced by gen::PyquenHadronizer::doSetRandomEngine(), gen::ExhumeHadronizer::doSetRandomEngine(), gen::HydjetHadronizer::doSetRandomEngine(), gen::Hydjet2Hadronizer::doSetRandomEngine(), and gen::Pythia6Hadronizer::doSetRandomEngine().

{ fRandomEngine = v; }

setSLHAFromHeader()

void Pythia6Service::setSLHAFromHeader

(

const std::vector< std::string > &

lines

)

Definition at line 323 of file Pythia6Service.cc.

References groupFilesInBlocks::block, gather_cfg::blocks, call_pyslha(), ztee::fd, createfilelist::int, mps_splice::line, groupFilesInBlocks::lines, ReggeGribovPartonMC_EposLHC_2760GeV_PbPb_cfi::model, openSLHA(), gen::pydat1_, MatrixUtil::remove(), submitPVValidationJobs::split(), mathSSE::sqrt(), contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, HcalDetIdTransform::transform(), relativeConstraints::value, and writeEcalDQMStatus::write.

Referenced by gen::Pythia6Hadronizer::initializeForExternalPartons().

                                                                        {
  std::set<std::string> blocks;
  unsigned int model = 0, subModel = 0;
  char tempslhaname[] = "pythia6slhaXXXXXX";
  int fd = mkstemp(tempslhaname);

  std::string block;
  std::stringstream f_info;
  for (std::vector<std::string>::const_iterator iter = lines.begin(); iter != lines.end(); ++iter) {
    f_info << *iter;

    std::string line = *iter;
    std::transform(line.begin(), line.end(), line.begin(), (int (*)(int))std::toupper);
    std::string::size_type pos = line.find('#');
    if (pos != std::string::npos)
      line.resize(pos);

    if (line.empty())
      continue;

    if (!boost::algorithm::is_space()(line[0])) {
      std::vector<std::string> tokens;
      boost::split(tokens, line, boost::algorithm::is_space(), boost::token_compress_on);
      if (tokens.empty())
        continue;
      block.clear();
      if (tokens.size() < 2)
        continue;
      if (tokens[0] == "BLOCK") {
        block = tokens[1];
        blocks.insert(block);
        continue;
      }

      if (tokens[0] == "DECAY") {
        block = "DECAY";
        blocks.insert(block);
      }
    } else if (block == "MODSEL") {
      std::istringstream ss(line);
      ss >> model >> subModel;
    } else if (block == "SMINPUTS") {
      std::istringstream ss(line);
      int index;
      double value;
      ss >> index >> value;
      switch (index) {
        case 1:
          pydat1_.paru[103 - 1] = 1.0 / value;
          break;
        case 2:
          pydat1_.paru[105 - 1] = value;
          break;
        case 4:
          pydat2_.pmas[0][23 - 1] = value;
          break;
        case 6:
          pydat2_.pmas[0][6 - 1] = value;
          break;
        case 7:
          pydat2_.pmas[0][15 - 1] = value;
          break;
      }
    }
  }
  write(fd, f_info.str().c_str(), f_info.str().size());
  close(fd);

  if (blocks.count("SMINPUTS"))
    pydat1_.paru[102 - 1] =
        0.5 - std::sqrt(0.25 - pydat1_.paru[0] * M_SQRT1_2 * pydat1_.paru[103 - 1] / pydat1_.paru[105 - 1] /
                                   (pydat2_.pmas[0][23 - 1] * pydat2_.pmas[0][23 - 1]));

  /*
    int unit = 24;
    fioopn_(&unit, fname, std::strlen(fname));
    std::remove(fname);

    call_pygive("IMSS(21)=24");
    call_pygive("IMSS(22)=24");
*/

  openSLHA(tempslhaname);
  std::remove(tempslhaname);

  if (model || blocks.count("HIGMIX") || blocks.count("SBOTMIX") || blocks.count("STOPMIX") ||
      blocks.count("STAUMIX") || blocks.count("AMIX") || blocks.count("NMIX") || blocks.count("UMIX") ||
      blocks.count("VMIX"))
    call_pyslha(1);
  if (model || blocks.count("QNUMBERS") || blocks.count("PARTICLE") || blocks.count("MINPAR") ||
      blocks.count("EXTPAR") || blocks.count("SMINPUTS") || blocks.count("SMINPUTS"))
    call_pyslha(0);
  if (blocks.count("MASS"))
    call_pyslha(5, 0);
  if (blocks.count("DECAY"))
    call_pyslha(2);

  return;
}

setSLHAParams()

void Pythia6Service::setSLHAParams

(

)

Definition at line 238 of file Pythia6Service.cc.

References mps_fire::end, DeadROC_duringRun::f1, geometryDiff::file, fParamSLHA, openSLHA(), AlCaHLTBitMon_QueryRunRegistry::string, and groupFilesInBlocks::temp.

Referenced by gen::Pythia6Gun::beginLuminosityBlock(), and gen::Pythia6Hadronizer::readSettings().

                                   {
  for (std::vector<std::string>::const_iterator iter = fParamSLHA.begin(); iter != fParamSLHA.end(); iter++) {
    if (iter->find("SLHAFILE", 0) == std::string::npos)
      continue;
    std::string::size_type start = iter->find_first_of("=") + 1;
    std::string::size_type end = iter->length() - 1;
    std::string::size_type temp = iter->find_first_of("'", start);
    if (temp != std::string::npos) {
      start = temp + 1;
      end = iter->find_last_of("'") - 1;
    }
    start = iter->find_first_not_of(" ", start);
    end = iter->find_last_not_of(" ", end);
    //std::cout << " start, end = " << start << " " << end << std::endl;
    std::string shortfile = iter->substr(start, end - start + 1);
    FileInPath f1(shortfile);
    std::string file = f1.fullPath();

    /*
    //
    // override what might have be given via the external config
    //
        std::ostringstream pyCard ;
        pyCard << "IMSS(21)=" << fUnitSLHA;
        call_pygive( pyCard.str() );
        pyCard << "IMSS(22)=" << fUnitSLHA;
        call_pygive( pyCard.str() );

    fioopn_( &fUnitSLHA, file.c_str(), file.length() );
*/

    openSLHA(file.c_str());
  }

  return;
}

Friends And Related Function Documentation

gen::pyr_

double gen::pyr_ ( int *  )

friend

Member Data Documentation

fInitialising

bool gen::Pythia6Service::fInitialising

private

Definition at line 51 of file Pythia6Service.h.

fParamCSA

std::vector<std::string> gen::Pythia6Service::fParamCSA

private

Definition at line 56 of file Pythia6Service.h.

Referenced by Pythia6Service(), setCSAParams(), and ~Pythia6Service().

fParamGeneral

std::vector<std::string> gen::Pythia6Service::fParamGeneral

private

Definition at line 55 of file Pythia6Service.h.

Referenced by Pythia6Service(), setGeneralParams(), and ~Pythia6Service().

fParamPYUPDA

std::vector<std::string> gen::Pythia6Service::fParamPYUPDA

private

Definition at line 58 of file Pythia6Service.h.

Referenced by Pythia6Service(), setPYUPDAParams(), and ~Pythia6Service().

fParamSLHA

std::vector<std::string> gen::Pythia6Service::fParamSLHA

private

Definition at line 57 of file Pythia6Service.h.

Referenced by Pythia6Service(), setSLHAParams(), and ~Pythia6Service().

fPythia6Owner

Pythia6Service * Pythia6Service::fPythia6Owner = nullptr

staticprivate

Definition at line 62 of file Pythia6Service.h.

Referenced by enter(), Pythia6Service(), and ~Pythia6Service().

fRandomEngine

CLHEP::HepRandomEngine* gen::Pythia6Service::fRandomEngine

private

Definition at line 53 of file Pythia6Service.h.

Referenced by randomEngine(), and setRandomEngine().

fUnitPYUPDA

int gen::Pythia6Service::fUnitPYUPDA

private

Definition at line 60 of file Pythia6Service.h.

Referenced by closePYUPDA(), and openPYUPDA().

fUnitSLHA

int gen::Pythia6Service::fUnitSLHA

private

Definition at line 59 of file Pythia6Service.h.

Referenced by closeSLHA(), and openSLHA().