gen::Pythia6Service Class Reference

#include <Pythia6Service.h>

Inheritance diagram for gen::Pythia6Service:

Public Member Functions
void	closePYUPDA ()
void	closeSLHA ()
virtual void	enter ()
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 ()
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 ()

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 = 0

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 25 of file Pythia6Service.h.

Constructor & Destructor Documentation

Pythia6Service::Pythia6Service

(

)

Definition at line 78 of file Pythia6Service.cc.

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

Pythia6Service::Pythia6Service

(

edm::ParameterSet const &

ps

)

Definition at line 83 of file Pythia6Service.cc.

References edm::hlt::Exception, fParamCSA, fParamGeneral, fParamPYUPDA, fParamSLHA, fPythia6Owner, edm::ParameterSet::getParameter(), getDQMSummary::iter, geometryCSVtoXML::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

(

)

Definition at line 160 of file Pythia6Service.cc.

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

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

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

Member Function Documentation

void Pythia6Service::closePYUPDA

(

)

Definition at line 281 of file Pythia6Service.cc.

References fiocls_(), and fUnitPYUPDA.

{

   fiocls_(&fUnitPYUPDA);
   
   return;

}

void Pythia6Service::closeSLHA

(

)

Definition at line 273 of file Pythia6Service.cc.

References fiocls_(), and fUnitSLHA.

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

{

   fiocls_(&fUnitSLHA);
   
   return;
}

void Pythia6Service::enter ( )

virtual

Reimplemented from gen::FortranInstance.

Definition at line 171 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;
   }
}

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

Definition at line 254 of file Pythia6Service.cc.

References call_pyupda(), gather_cfg::cout, 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;

}

void Pythia6Service::openSLHA

(

const char *

file

)

Definition at line 238 of file Pythia6Service.cc.

References gen::call_pygive(), 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;

}

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

inline

Definition at line 47 of file Pythia6Service.h.

References fRandomEngine.

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

{ return fRandomEngine; }

void Pythia6Service::setCSAParams

(

)

Definition at line 204 of file Pythia6Service.cc.

References fParamCSA, i, getDQMSummary::iter, reco_skim_cfg_mod::maxSize, reco::return(), SETCSAPARBUFSIZE, gen::txgive_(), and gen::txgive_init_().

Referenced by gen::Pythia6Gun::beginLuminosityBlock(), gen::Cascade2Hadronizer::initializeForInternalPartons(), gen::Cascade2Hadronizer::readSettings(), 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
}

void Pythia6Service::setGeneralParams

(

)

Definition at line 188 of file Pythia6Service.cc.

References gen::call_pygive(), fParamGeneral, getDQMSummary::iter, and reco::return().

Referenced by ParticleReplacerParticleGun::beginJob(), ParticleReplacerZtautau::beginJob(), gen::Pythia6Gun::beginLuminosityBlock(), GenMuonRadiationAlgorithm::compFSR(), gen::Cascade2Hadronizer::initializeForInternalPartons(), gen::Cascade2Hadronizer::readSettings(), gen::PyquenHadronizer::readSettings(), gen::HydjetHadronizer::readSettings(), gen::ExhumeHadronizer::readSettings(), and gen::Pythia6Hadronizer::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 ;
}

void Pythia6Service::setPYUPDAParams

(

bool

afterPyinit

)

Definition at line 331 of file Pythia6Service.cc.

References end, python.connectstrParser::f1, mergeVDriftHistosByStation::file, fParamPYUPDA, edm::FileInPath::fullPath(), getDQMSummary::iter, openPYUPDA(), dqm_diff::start, AlCaHLTBitMon_QueryRunRegistry::string, and groupFilesInBlocks::temp.

Referenced by gen::Pythia6Hadronizer::initializeForExternalPartons(), gen::Cascade2Hadronizer::initializeForInternalPartons(), 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;
}

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

inline

Definition at line 48 of file Pythia6Service.h.

References fRandomEngine, and gen::v.

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

{ fRandomEngine = v; }

void Pythia6Service::setSLHAFromHeader

(

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

lines

)

Definition at line 382 of file Pythia6Service.cc.

References createPayload::block, gather_cfg::blocks, call_pyslha(), mergeVDriftHistosByStation::file, alignmentValidation::fname, cmsHarvester::index, getDQMSummary::iter, geometryCSVtoXML::line, NULL, openSLHA(), dbtoconf::out, gen::pydat1_, python.multivaluedict::remove(), reco::return(), split, mathSSE::sqrt(), contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, create_public_lumi_plots::transform, estimatePileup_makeJSON::trunc, and relativeConstraints::value.

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

{

    std::set<std::string> blocks;
    unsigned int model = 0, subModel = 0;

    const char *fname = std::tmpnam(NULL);
    std::ofstream file(fname, std::fstream::out | std::fstream::trunc);
    std::string block;
    for(std::vector<std::string>::const_iterator iter = lines.begin();
        iter != lines.end(); ++iter) {
        file << *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.size())
                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;
            }
        }
    }
    file.close();

    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( fname ) ;
    std::remove( fname );
    
    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 ;

}

void Pythia6Service::setSLHAParams

(

)

Definition at line 290 of file Pythia6Service.cc.

References end, python.connectstrParser::f1, mergeVDriftHistosByStation::file, fParamSLHA, edm::FileInPath::fullPath(), getDQMSummary::iter, openSLHA(), dqm_diff::start, AlCaHLTBitMon_QueryRunRegistry::string, and groupFilesInBlocks::temp.

Referenced by gen::Pythia6Gun::beginLuminosityBlock(), gen::Cascade2Hadronizer::initializeForInternalPartons(), gen::Cascade2Hadronizer::readSettings(), 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

double gen::pyr_ ( int *  )

friend

Member Data Documentation

bool gen::Pythia6Service::fInitialising

private

Definition at line 53 of file Pythia6Service.h.

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

private

Definition at line 58 of file Pythia6Service.h.

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

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

private

Definition at line 57 of file Pythia6Service.h.

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

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

private

Definition at line 60 of file Pythia6Service.h.

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

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

private

Definition at line 59 of file Pythia6Service.h.

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

Pythia6Service * Pythia6Service::fPythia6Owner = 0

staticprivate

Definition at line 64 of file Pythia6Service.h.

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

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

private

Definition at line 55 of file Pythia6Service.h.

Referenced by gen::pyr_(), randomEngine(), and setRandomEngine().

int gen::Pythia6Service::fUnitPYUPDA

private

Definition at line 62 of file Pythia6Service.h.

Referenced by closePYUPDA(), and openPYUPDA().

int gen::Pythia6Service::fUnitSLHA

private

Definition at line 61 of file Pythia6Service.h.

Referenced by closeSLHA(), and openSLHA().