Pythia6 Interface to CMSSW

Complete:

Introduction

Pythia is a general purpose event generator, containing theory and models for a number of physics aspects, including hard and soft interactions, parton distributions, initial and final state parton showers, multiple interactions, fragmentation ("Lund" model) and decays.

As a Monte Carlo tool, it is centrally supported via LCG GENSER, where highlights and tips are offered.

Detailed information can be found at the Pythia6 Home page, including the complete Pythia6 Manual.

It has been largely used in the CMS collaboration for event generation, as well as for hadronization of the parton-level events coming from one or another Matrix Element (ME) tool of interest to CMS (see CMS.GeneratorTaskList for more details).

Pythia6Interface in CMSSW

The main goal of this document is introduce the user to the basic functionalities of the CMSSW-Pythia6 interface.

Pythia6 is interfaced to CMSSW via GeneratorInterface/Pythia6Interface package.

The software implementation is based on the dedicated Proposal (see attached document), that's been largely discussed and approved by the CMS Offline experts.

The two major software components are

• Pythia6GeneratorFilter - full event generation
• Pythia6HadronizerFilter - processing of parton-level event by an ME generator

Both components deliver the same output: HepMCProduct and GenEventInfoProduct (these are common across CMSSW interfaces to all multi-purpose generators).

A brief introduction is also given in the CMS Offline WorkBook, and includes pointers to necessary CMSSW components.

In this writeup we provide more examples, explain some of the configuration parameters, describe additional features and custom build procedures (for advanced development purposes), etc.

We would like to point out that widely use the generic notation CMSSW_X_Y_Z.
In general, instructions should be valid starting development cycle 3_1_0 (3_1_0_pre2 and onward).

We assume that users are already familiar with the basics of CMSSW. If not, please visit this super-short introduction.

A typical user does not have to build the package in her/his local SCRAM project area. However, if one wishes to do so, we'll give explicit instructions downstream this page.

Those users that have experience with earlier implementation of Pythia6Interface may notice that, unlike "traditional" Pythia6, the CMSSW interface does NOT give as many printouts; please be advises that the level of Pythia6 general verbosity, including Pythia6 banner, has been intentionally brought to a very minimum, as not to increase the size of the production logfiles.

A walk-through example configuration fragment for ttbar event generation

As already explained in the WorkBook, a large collection of pre-fabricated generator-level configuration include is provided via CMSSW packages Configuration/Generator and Configuration/CMS.GenProduction.

As many CMSSW components, event generation modules are largely configured at run time.
The configuration language is greatly shared between Pythia6GeneratorFilter and Pythia6HadronizerFilter. However, the later has a possibility to employ a utility that determines so called internal validity of an event; this is called parton-shower matching.
In this document we will first cover configuration parameters that are common across "Generator" and "Hadronizer". Then we will provide tips on the parameters that are specific to a "Hadronizer".

Here we'd like to walk you through example configuration for generating ttbar samples. This fragment, as any other in the collection, can be processed through cmsDriver.py, to obtain a complete CMSSW configuration file.

Now let us revisit some specific details of the configuration.
Obviously, the very first line in the example

import FWCore.ParameterSet.Config as cms

is related to the mechanics of the python configuration language.
The next line

source = cms.Source("EmptySource")

plugs in the event loop driver (see details).
The following line

from Configuration.Generator.PythiaUESettings_cfi import *

is important because it brings standard pre-fabricated block to describe setting for the Underlying Event (UE), as currently approved by the CMS collaboration. Later in this writeup we will revisit several details of the UE settings.

Specifically, the configuration of the generator's module, Pythia6GeneratorFilter in this case, starts with the line

generator = cms.EDFilter("Pythia6GeneratorFilter",

followed by the module's configuration parameters; remember that "generator" is the only label allowed for any event generation software component within CMSSW, as we already mentioned in the WorkBook.
The following several parameters are of service nature, as they allow various levels of verbosity (here all configured to "None").

    pythiaHepMCVerbosity = cms.untracked.bool(False),
    maxEventsToPrint = cms.untracked.int32(0),
    pythiaPylistVerbosity = cms.untracked.int32(0),

For example, if a user wished to print the final-state event in the HepMC format (HepMCProduct), she/he should turn pythiaHepMCVerbosity from False to True:

pythiaHepMCVerbosity = cms.untracked.bool(True)

Obviously, maxEventsToPrint defines how many events one wants to display (starting from the 1st event; skipping events is NOT possible).
Printing out Pythia6-specific event record is controlled by the pythiaPylistVerbosity parameters; if you are uncertain what setting to choose, please look for the available options (Pythia6 event record is printed via call to PYLIST routine, and the setting is just the input argument to it).

Additional service parameters are:

   filterEfficiency = cms.untracked.double(1.0),
   crossSection = cms.untracked.double(55000000000.),
   crossSectionNLO=cms.untracked.double(-1.),

These are so called user-determined parameters; they are NOT used by Pythia6 in the event generation process, but they get recorded within GenEventInfoProduct. Pythia6-calculated cross section is recorded separately, also within GenEventInfoProduct.
Note that the crossSection and crossSectionNLO parameters are not included in the example we walk through, but we think it is useful to list then here.

All these parameters are untracked, i.e. if you generate two samples of a particular topology but with different settings of the above parameters, you should be able to merge the samples together.

Finaly, the two parameters that are most essential ones as they determine the center of mass energy and event topology to be generated by Pythia6:

  comEnergy = cms.double(10000.0),
   PythiaParameters = cms.PSet(...)

Obviously, thse parameter are tracked; i.e. you will NEVER be able to merge samples generated with different settings of these parameters, as it would be a nonsense from the physics point of view.

In addition to this, we would like to mention one more important features, that is available starting CMSSW_4_3_X cycle.
While the default initial state for Pythia6 (and all other generators) in CMS remains proton-proton (PPInitialState), we now allow 3 other initial states, for tuning and analysis needs. Additional options are:

PPbarInitialState = cms.PSet ( )

ElectronPositronInitialState = cms.PSet ( )

 ElectronProtonInitialState = cms.PSet(
   electronMomentum = cms.double(400.),
   protonMomentum   = cms.double(-400.)
 ),

In the first two cases the event kinematics will be defined by the comEnergy parameter. In the third case, additional parameters are required, to specify beam pz and direction.
All these parameter sets are tracked, thus you wont be able to merge samples with different settings. However, the system will internally check if anything different from default (PPInitialState) has been specified; if not, default will be kept. Thus, it is NOT necessary to give PPInitialState in your configuration.

Now, we would like to return to PythiaParameters. The format of the PythiaParameters configuration subset greatly follows native language of Pythia6 (see complete Pythia6 Manaul), and allows to pass process parameters to Pythia6 generator at run time.

Specific to the Pythia6Interface is that it allows to combine Pythia6 configuration cards into groups of character strings:

     PythiaParameters = cms.PSet(
        pythiaUESettingsBlock,
        processParameters = cms.vstring(...),
        # This is a vector of ParameterSet names to be read, in this order
        parameterSets = cms.vstring('pythiaUESettings', 
            'processParameters')
    )

Additional parameter in the subset, parameterSets, actually determines which groups must be picked up by Pythia6.
This approach allows to re-use, in a compact form, some of the important pre-fabricated settings, for example, PythiaUESettings, which we would like to visit below.
Cards provided in the block

        processParameters = cms.vstring('MSEL      = 0     ! User defined processes', 
            'MSUB(81)  = 1     ! qqbar to QQbar', 
            'MSUB(82)  = 1     ! gg to QQbar', 
            'MSTP(7)   = 6     ! flavour = top', 
            'PMAS(6,1) = 175.  ! top quark mass'),

are specific to ttbar event generation.
Later in this document we will provide example configurations for different event topologies.

Comments by Stephen Mrenna (mailto:mrenna@fnalNOSPAMPLEASE.gov)

The above can be accomplished using only 'MSEL=6'

        processParameters = cms.vstring('MSEL=6     ! Top pair processes', 
        'PMAS(6,1) = 175.  ! top quark mass'),

This is recommended (by me) because it is easily generalizable to b quark pair production ('MSEL=5') and 4th generation quark production ('MSEL=7' or 'MSEL=8', but also modify the 4th generation CKM elements: 'VCKM(4,3)=.01', for example)

Underlying Event settings

Now let us revisit the contents of the PythiaUESettings_cfi.py, as it represents currently approved standard settings.
This configuration block is reasonably annotated and can serve as a mini-guide by itself. However, we would like to point your attention to several specific settings.
These two cards

        'MSTJ(22)=2     ! Decay those unstable particles', 
        'PARJ(71)=10 .  ! for which ctau  10 mm', 

will tell Pythia6 to decay unstable particles that can travel no farther than 10mm (1cm) from the collision point. Particles of life time greater than 10mm have a chance to interact with the detector's material prior they can decay in flight; for this reason it has been decided to keep then undecayed by the generator and then treated by the detector simulation step.
Another pair of Pythia6 cards that we would like to point out are:

        'MSTP(51)=10042 ! structure function chosen (external PDF CTEQ6L1)',
	'MSTP(52)=2     ! work with LHAPDF',

These settings mean that the for the generation we choose the PDF set from an external package LHAPDF, rather than one of the options available within Pythia6 package.

For other details on various Pythia6-specific cards one should consult complete Pythia6 Manaul, as already stated above.

Please note that PythiaUESettings_cfi.py has a "twin" in the Configuration/CMS.GenProduction package that is actually used in the applications for central production.
However, we advise you to use the "twin" from Configuration/CMS.GenProduction ONLY if you intend to add your configuration to this package - otherwise the configuration language processor will report an error, because CMS.GenProduction is NOT distributed as a part of CMSSW. If your application belongs to a domain other than CMS.GenProduction, please use those includes from Configuration/Generator.

You may also find it interesting that for future studies we have alternative "tune" for the UE, all in the same area Configuration/Generator/python:

• PythiaUEP0Settings_cfi.py
• PythiaUEProPT0Settings_cfi.py
• PythiaUEProQ20Settings_cfi.py

Example 1: b-bbar

Now suppose you want to generate b-bbar events. As compared to the avobe ttbar example, the changes to your Pythia6GeneratorFilter configuration will be only in the in the processParameters vector of strings, which will look as follows:

  processParameters = cms.vstring(
      'MSEL=0         ! User defined processes',
      'MSUB(81)=1     ! qq->QQ massive',
      'MSUB(82)=1     ! gg->QQ massive',
      'MSTP(7)=5      ! 5 for BB_bar',
      'CKIN(3)=50.    ! Pt hat lower cut',
      'CKIN(4)=120.   ! Pt hat upper cut',     
      'CKIN(13)=0.    ! etamin',
      'CKIN(14)=2.5   ! etamax',
      'CKIN(15)=-2.5  ! -etamax',
      'CKIN(16)=0.    ! -etamin'  )   

Here and in the examples below we demonstrate how a user needs to modify the =processParameters group of cards of the very first ttbar example, in order to re-configure Pythia6 generation for different topologies. Note that you are not really obliged to use processParameters as a name of group of Pythia6 cards; for example, myParameters will be an equally good name, but you will need to reflect it properly in the field of the parameterSets, like this:

parameterSets = cms.vstring('pythiaUESettings', 'myParameters')

(this name parametersSets is NOT negotiable but is mandatory).

Comments by Stephen Mrenna (mailto:mrenna@fnalNOSPAMPLEASE.gov)

As suggested above, these processes can be activated using 'MSEL=5'. Note, however, that direct production will only produce a fraction of the b quark pairs possible from QCD. The two other important mechanisms are:

1. flavor excitation (bg -> bg): ISR will product the other b quark

2. gluon splitting (gg -> gg, g-> b b~): the splitting is "rare", but the underlying cross section is "huge"

Example 2: Higgs

More  Less 

If you want Higgs production, an example of processParameters (or similar) group of Pythia6 configuration cards will like like this:

  processParameters = cms.vstring(
      'PMAS(25,1)=300. ! Higgs',
      'MSUB(3)=1       ! fi ~fj  ->  H',
      'MSUB(102)=1     !  g   g  ->  H',
      'MSUB(123)=1     ! fi  fj  ->  H  fi fj   (ZZ fusion)',
      'MSUB(124)=1     ! fi  fj  ->  H  fk fl   (W+W- fusion)',
      'MSTJ(11)=3      ! Fragmentation',
      'MSTJ(41)=1      ! Switch off Pythia QED bremsshtrahlung')

Example 3: Z pair

More  Less 

 processParameters = cms.vstring(
      'MSEL=0          ! define production mechanism using MSUB',
      'MSUB(22)=1      ! Z pair production',
      'MSTJ(41)=1      ! Switch off Pythia QED bremsshtrahlung',
      'CKIN(3)=25.5    !',
      'CKIN(41)=5.     !',
      'CKIN(42)=150.   !',
      'CKIN(43)=5.     !',
      'CKIN(44)=150.   !')

Example 4: msugra

More  Less 

processParameters = cms.vstring(
      'MSEL=39         ! inclusive SUSY',
      'IMSS(1)=2       ! mSUGRA',
      'RMSS(4)=1.      ! SIGN(MU)',
      'RMSS(5)=10.     ! TAN(BETA)',
      'RMSS(16)=0.     ! A0',
      'RMSS(1)=200.    ! M12',
      'RMSS(8)=250.    ! M0')

Example 5: qqJets

More  Less 

For qqJets.cfg change the "myParameters" subset in your config file as follows:

processParameters = cms.vstring(
      'MSEL=0          !  for user specification of sub-processes',
      'MSUB(11)=1      !  qq->qq   ON, if one needs quark jets',
      'MSUB(68)=1      !  gg->gg   ON, if one needs gluon jets',
      'CKIN(3)=100.    !  Pt low cut but also the Et jet required',
      'CKIN(13)=0.     !  etamin',
      'CKIN(14)=1.4    !  etamax',
      'CKIN(15)=-1.4   ! -etamax',
      'CKIN(16)=0.     ! -etamin')

Example 6: W pair

More  Less 

processParameters = cms.vstring(
      'MSEL=0          !',
      'MSUB(25)=1      !',
      'MDME(190,1)=0   !',
      'MDME(191,1)=0   !',
      'MDME(192,1)=0   !',
      'MDME(193,1)=0   !',
      'MDME(194,1)=0   !',
      'MDME(195,1)=0   !',
      'MDME(196,1)=0   !',
      'MDME(197,1)=0   !',
      'MDME(198,1)=0   !',
      'MDME(199,1)=0   !',
      'MDME(200,1)=0   !',
      'MDME(201,1)=0   !',
      'MDME(202,1)=0   !',
      'MDME(203,1)=0   !',
      'MDME(204,1)=0   !',
      'MDME(205,1)=0   !',
      'MDME(206,1)=1   ! (W+ --> nu e+    ON)',
      'MDME(207,1)=1   ! (W+ --> nu mu+   ON)',
      'MDME(208,1)=1   ! (W+ --> nu tau+  ON)',
      'MDME(209,1)=0   !')

Example 7: How to generate SUSY samples using an external SLHA spectrum file

For an accurate calculation of SUSY particle masses, you can use a dedicated program (ISASUGRA, SUSPECT, SOFTSUSY, ...) to calculate the spectrum and let Pythia6 use this to generate the events.

SLHA file reading option is available by both Pythia6-based generator modules, Pythia6GeneratorFilter and Pythia6HadronizerFilter.
This means that, in addition to Pythia6 SUSY event generation, one can also develop such events from externally generator partons.

A collection of pre-generated SLHA spectra is available in CMSSW, as part of the %CLSL%Configuration/Generator/data][Configuration/Generator/data]] area.

We would like to visit an example configuration file for this type of event generation, Configuration/Generator/python/LM9p_cff.py.
To a great extent the contents will resemble the very first ttbar example that we visited earlier in this document. However, we would like to stress several difference.

Please note the following important configuration parameter within PythiaParameters subset:

SLHAParameters = cms.vstring('SLHAFILE = Configuration/Generator/data/CSA07SUSYBSM_LM9p_sftsdkpyt_slha.out'),

which is also listed in the parameterSets field:

 parameterSets = cms.vstring('pythiaUESettings', 'processParameters','SLHAParameters')

The settings of your processParameters group of cards should like like this:

        processParameters = cms.vstring(
		'MSEL=39                  ! All SUSY processes ',
		'IMSS(1) = 11             ! Spectrum from external SLHA file')

These settings will be standard for telling Pythia to read an SLHA spectrum; you may notice them in use through several other examples in the collection, such as GM1_cfi.py, LM1_cfi.py, or LM5_cfi.py configuration fragments.
Please note that explicit cards (present in the examples)

		'IMSS(21) = 33            ! LUN number for SLHA File (must be 33) ',
		'IMSS(22) = 33            ! Read-in SLHA decay table '),

are a left over from an older implementation; they are no longer necessary as this has been re-routed into the core code of Pythia6Interface, for consistency.

If you would like to generate an SLHA spectrum file on your own, with ISASUGRA, you can download and run the "isasugra.x" executable from /afs/cern.ch/user/p/paige/public/isajet. Other recommended programs are SUSPECT and SOFTSUSY.

Example 8: How to modify particle properties & decay branching ratios using a PYUPDA card file.

If you wish to modify particle properties (e.g. mass, lifetime) or decay modes, or wish to define entirely new exotic particles, you can do this using a PYUPDA card file. (Allternatively, in many cases, this can instead be done with SLHA cards, as described in the previous section).

(This only works in CMSSW 3.4, but may work in early versions if you compile with a recent version of GeneratorInterface/!Pythia6Interface/).

Pythia cards illustrating how to do this can be found here. They produce an H0, which decays to two long-lived exotic particles (newly defined), which then each decay to a quark-antiquark pair. They include the following lines, which specify the location of the PYUPDA card file and ensure that Pythia uses it to determine particle properties and decay modes:

        
        PYUPDAParameters = cms.vstring(
         'PYUPDAFILE =  Configuration/Generator/data/Pythia_H0_pyupda.in'
#        "PYUPDApostPYINIT"
        )

(N.B. By default, Pythia uses the PYUPDA cards before its initialisation using PYINIT. Where Pythia has theoretical reasons for believing that it knows a particle's properties, (e.g. gauge bosons), the call to PYINIT may overwrite the changes to those particle's properties made by PYUPDA, and so ignore the latter. If you find this is happening, you can try introducing the PYUPDApostPYINIT parameter above, which causes the PYUPDA cards to be used after the call to PYINIT. Do not do this unless you find it is necessary, since Pythia is not guaranteed to work in this mode (but usually does). If you do use this option, print out a few events to check that it is working).

(N.B. If you are modifying gauge boson or SUSY branching ratios, it is recommended not to delete rows from the existing branching ratio table, although you can add new ones at the end of it. This is because Pythia may use the original rows to infer the particle's couplings and hence production cross-sections. It makes hard-wired assumptions when doing this about the location of these rows, and will be confused if you delete any. Similarly, beware of setting these original branching ratios to exactly zero, since this can result in the particles couplings to these final state particles being zero and so result in it having zero production cross section. This prevents Pythia simulating it. You can safely reduce them by a large factor (e.g. 1000) however.

(N.B. If you wish a previously stable particle to decay, then in addition to adding a decay table for it, you should specifying in the cards that it has a non-zero width).

How can you create your PYUPDA input card file in the first place ? This is easy. Replace the above configuration parameters by:

        
        PYUPDAParameters = cms.vstring(
           'PYUPDAFILE =  pyupda.out',
           'PYUPDAWRITE'
        )

and run CMSSW for a few events. It will print to the file "pyupda.out" the (PYUPDA format) properties and decay modes of all known particles. You can edit this, keeping just the particles you are interested in, and modifying their properties. An example is here. The format of this file is described in the PYUPDA section of the Pythia6 Manual.

Example 9: CSA mode with Event Reweighting

The CMSSW interface to Pythia6 also allows to re-weight events, via multiplying the standard PYTHIA differential cross-section by a process- and kinematics-dependent factor WTXS. For MSTP(142)=1 this corresponds to generation of weighted events, with weight 1/WTXS, while for MSTP(142)=2 it corresponds to a modification of the underlying physics.

Please note that we store two numbers in the event weight container: one corresponds to the Pythia6 variable VINT(97), and the other corresponds to 1./VINT(99), where VINT(99) is the same as WTXS.

We can exemplify this feature with the Configuration/Generator/python/ QCDForPF_cfi.py application.

Please note how the feature is activated by this group of cards withing processParameters subset:

  CSAParameters = cms.vstring(
            'CSAMODE = 7     ! towards a "flat" QCD spectrum',
            'PTPOWER = 4.5   ! reweighting of the pt spectrum'
 )

Other available selections of reweighting algorithm (CSAMODE card) are:

                  1 for QCD dijet
                  2 for EWK soup 
                  3 for HLT soup
                  4 for soft muon soup
                  5 for exotics soup ?
                  6 for cross-section reweighted quarkonia production

Example 10: How to Process Externally Generated Partons with Pythia6

As already mentioned throughout CMS Generators documents, Pythia6 can also be used to developed an event starting from partons generated with one or another ME tool.
Here we would like to show how one can compose an application for processing a MadGraph sample with Pythia6.
Before everything we need to stress that the job is done with a dedicated module Pythia6HadronizerFilter, which is different from Pythia6GeneratorFilter used for full event generation (and referred to in all the examples above).
Please review pre-fabricated generator-level configuration fragment Configuration/Generator/python/MadGraph_matching_cfi.py. You can process it through cmsDriver.py exactly as shown in the previous sections.
In the fragment there will be several details of interest for you.
First of all, the even loop is driven by a special purpose LHESource (rather than EmptySource)

source = cms.Source("LHESource",
    fileNames = cms.untracked.vstring(
    'file:../../../GeneratorInterface/Pythia6Interface/test/ttbar_5flavours_xqcut20_10TeV.lhe')
)

which is feed with the parton-level MadGraph sample. Please be advised that in this example we refer to a "private" sample that is normally used for debugging by developers. In the future we'll offer other sample as they become available. As an alternative, you can produce your own MadGraph sample, as described in the dedicated CMS Madgraph document.
Next aspect of your interest is this:

generator = cms.EDFilter("Pythia6HadronizerFilter",

- it means that we use Pythia6-based module that is dedicated to processing externally generated partons, rather than Pythia6GeneratorFilter shown in previous examples.
The module is configured specifically for processing MadGraph events:

        processParameters = cms.vstring('MSEL=0         ! User defined processes',
                        'PMAS(5,1)=4.4   ! b quark mass',
                        'PMAS(6,1)=172.4 ! t quark mass',
                        'MSTJ(1)=1       ! Fragmentation/hadronization on or off',
                        'MSTP(61)=1      ! Parton showering on or off'),

(i.e. for processing, for example, Alpgen sample the settings will be different).
This example configuration also includes usage of the dedicated Madgraph parton-shower matching algorithm, to decide on the event internal validity, or to veto events of incorrect topology:

    jetMatching = cms.untracked.PSet(
       scheme = cms.string("Madgraph"),
       mode = cms.string("auto"),       # soup, or "inclusive" / "exclusive"
       MEMAIN_etaclmax = cms.double(5.0),
       MEMAIN_qcut = cms.double(30.0),
       MEMAIN_minjets = cms.int32(-1),
       MEMAIN_maxjets = cms.int32(-1),
    )

Please note that the use of matching procedure is optional; Pythia6HadronizerFilter may operate without it.
However, if you choose to use parton-shower matching, you will need to remember that in case an event is vetoed, the EDFilter will return a false code, and the HepMCProduct will be empty. Those event will be filtered out of the output, because event generation step is included in the "production filtering sequence":

ProductionFilterSequence = cms.Sequence(generator)

(which will later on will be reflected in the PoolOutputModule configuration, if you process the fragment through cmsDriver.py).

Pythia6HadronizerFilter is also used to process externally generated parton level events by any ME tool, for example Alpgen partons or, in a simpler case, by the CMSSW-incorporated BcGenerator.

How to build Pythia6Interface package

As already said at the beginning of this page, a typical user does not need to build the package to run Pythia6 within CMSSW.

However, we provide instructions for those who may want to test some custom features.

• First of all, we have to create your local CMSSW_X_Y_Z project,

  scramv1 project CMSSW CMSSW_X_Y_Z
  

• and get the code from the CVS repository

  cd CMSSW_X_Y_Z/src/
  project CMSSW
  cvs co -r CMSSW_X_Y_Z GeneratorInterface/Pythia6Interface
  

• Then we setup our enviroment

  cd GeneratorInterface/Pythia6Interface
  

  • if you are using csh

    eval `scramv1 run -csh`
    

  • if you are using bash

    eval `scramv1 run -sh`
    

• and compile the code:

  scramv1 b
  

Setting up other Pythia6 versions with CMSSW

Only one Pythia6 version will be officially supported in every CMSSW release.

However, for testing purposes or specific studies developers and/or advanced user may need to use a version that is different from the default one.
For these cases we provide a short recipe for locally building Pythia6 libraries and configuring them in the user's CMSSW project.
The procedure is relatively simple and "generic" enough to apply to many other generator tools interfaced with CMSSW, although maybe with minor modifications.

• cp /afs/cern.ch/sw/lcg/external/MCGenerators/distribution/pythia6-version-src.tgz
  were version is the version you're interested about (for example 420, which is the latests).
• tar xvfz pythia6-version-src.tgz
• cd pythia/version
• Now you want to be careful and build your Pythia6 libraries with the same compiler that is used in CMS(SW).
  It can be set up by executing

  eval `scramv1 ru -(c)sh`
  

  under your local scram CMSSW area or in the standard install area on the CMSSW release you are interested about.
  If you don't want to setup CMSSW runtime environment just yet, you can use the following recipe:

  source $GCC_BASE/etc/profile.d/init.csh
  

  where where GCC_BASE value can be obtained as output of

  scramv1 tool tag cxxcompiler GCC_BASE
  

  executed in your release area or in the standard CMSSW release area.
• ./configure --lcgplatform=${SCRAM_ARCH} --userfflags=-fno-automatic --enable-shared
  (brief instructions are provided via README file)
• make
• Now move to your local CMSSW area and reconfigure it with your locally build Pythia6 libraries, by executing the following:

  scramv1 setup -i pythia6
  

  and answering subsequent questions about the location of the "base", the includes, and the libraries - obviously, you should give full path to the area where your local install of Pythia6 is.
• Now you are ready to locally re-build your GeneratorInterface/Pythia6Interface package.

WARNING !!! Since several other external packages used with CMSSW are compiled with Pythia6, for example Tauola, you may want to make sure the correct Pythia6 libraries are used (that is, YOUR libraries). You can do so via

ldd /PATH/TO/YOUR/LIB/<lib-of-your-interest>.so

Review status

Reviewer/Editor and Date (copy from screen)	Comments
Main.tomalini - 12 Nov. 2008	Added PYUPDA section