ROOT logo

class TPythia6: public TGenerator


TPythia is an interface class to F77 version of Pythia 6.2
To use this class you must install a version of pythia6.
see the installation instructions at

CERNLIB event generators, written by T.Sjostrand.
For the details about these generators look at Pythia/Jetset manual:

P  P  Y Y    T   H   H  I   A A          J E      T   S     E      T
PPP    Y     T   HHHHH  I  AAAAA         J EEE    T    SSS  EEE    T
P      Y     T   H   H  I  A   A      J  J E      T       S E      T
P      Y     T   H   H III A   A       JJ  EEEE   T    SSS  EEEE   T

*......*                  Welcome to the Lund Monte Carlo!
*::::::!!::::::::::::::*            This is PYTHIA version 5.720
*::::::::!!::::::::::::::::*        Last date of change: 29 Nov 1995
*:::::::::!!:::::::::::::::::*         This is JETSET version 7.408
*::::::::!!::::::::::::::::*!       Last date of change: 23 Aug 1995
*::::::!!::::::::::::::* !!
!! *:::!!:::::::::::*    !!                 Main author:
!!     !* -><- *         !!              Torbjorn Sjostrand
!!     !!                !!        Dept. of theoretical physics 2
!!     !!                !!              University of Lund
!!                       !!                Solvegatan 14A
!!        ep             !!             S-223 62 Lund, Sweden
!!                       !!          phone: +46 - 46 - 222 48 16
!!                 pp    !!          E-mail:
!!                       !!         Copyright Torbjorn Sjostrand
!!                                     and CERN, Geneva 1993

The latest program versions and documentation is found on WWW address

When you cite these programs, priority should always be given to the
latest published description. Currently this is
T. Sjostrand, Computer Physics Commun. 82 (1994) 74.
The most recent long description (unpublished) is
T. Sjostrand, LU TP 95-20 and CERN-TH.7112/93 (revised August 1995).
Also remember that the programs, to a large extent, represent original
physics research. Other publications of special relevance to your
studies may therefore deserve separate mention.

Function Members (Methods)

voidTObject::AbstractMethod(const char* method) const
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidTGenerator::Browse(TBrowser* b)
virtual voidTObject::Browse(TBrowser* b)
static TClass*Class()
static TClass*TGenerator::Class()
static TClass*TNamed::Class()
static TClass*TObject::Class()
virtual const char*TObject::ClassName() const
virtual voidTNamed::Clear(Option_t* option = "")
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TNamed::Clone(const char* newname = "") const
virtual TObject*TObject::Clone(const char* newname = "") const
voidCloseFortranFile(int lun)
virtual Int_tTNamed::Compare(const TObject* obj) const
virtual Int_tTObject::Compare(const TObject* obj) const
virtual voidTNamed::Copy(TObject& named) const
virtual voidTObject::Copy(TObject& object) const
virtual voidTObject::Delete(Option_t* option = "")MENU
virtual Int_tTGenerator::DistancetoPrimitive(Int_t px, Int_t py)
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTGenerator::Draw(Option_t* option = "")
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTGenerator::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual voidTNamed::FillBuffer(char*& buffer)
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
virtual voidGenerateEvent()
virtual voidTGenerator::GenerateEvent()
doubleGetBRAT(int i)
doubleGetCKIN(int i)
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual const char*TObject::GetIconName() const
intGetIMSS(int i)
intGetK(int ip, int i)
intGetKCHG(int ip, int i)
intGetKFDP(int i, int j)
Int_tGetKFIN(int i, int j)
virtual TObjArray*TGenerator::GetListOfParticles() const
intGetMDCY(int i, int j)
intGetMDME(int i, int j)
intGetMINT(int i)
intGetMRPY(int i)
intGetMSTI(int i)
intGetMSTJ(int i)
intGetMSTP(int i)
intGetMSTU(int i)
intGetMSUB(int i)
intGetMWID(int i)
virtual const char*TNamed::GetName() const
virtual const char*TObject::GetName() const
Int_tTGenerator::GetNumberOfParticles() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
doubleGetP(int ip, int i)
virtual Double_tTGenerator::GetParameter(const char*) const
doubleGetPARF(int i)
doubleGetPARI(int i)
doubleGetPARJ(int i)
doubleGetPARP(int i)
virtual TParticle*TGenerator::GetParticle(Int_t i) const
doubleGetPARU(int i)
doubleGetPMAS(int ip, int i)
virtual TObjArray*TGenerator::GetPrimaries(Option_t* option = "")
char*GetPROC(int i)
Float_tTGenerator::GetPtCut() const
doubleGetRMSS(int i)
doubleGetRRPY(int i)
doubleGetSMW(int i)
doubleGetSMZ(int i)
virtual const char*TNamed::GetTitle() const
virtual const char*TObject::GetTitle() const
doubleGetUMIX(int i, int j)
virtual UInt_tTObject::GetUniqueID() const
doubleGetV(int ip, int i)
doubleGetVCKM(int i, int j)
doubleGetVINT(int i)
doubleGetVMIX(int i, int j)
doubleGetWIDS(int i, int j)
doubleGetZMIX(int i, int j)
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTNamed::Hash() const
virtual ULong_tTObject::Hash() const
virtual TObjArray*ImportParticles(Option_t* option = "")
virtual TObjArray*TGenerator::ImportParticles(Option_t* option = "")
virtual Int_tImportParticles(TClonesArray* particles, Option_t* option = "")
virtual Int_tTGenerator::ImportParticles(TClonesArray* particles, Option_t* option = "")
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
voidInitialize(const char* frame, const char* beam, const char* target, float win)
virtual voidTObject::Inspect() constMENU
static TPythia6*Instance()
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual TClass*TGenerator::IsA() const
virtual TClass*TNamed::IsA() const
virtual TClass*TObject::IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTNamed::IsSortable() const
virtual Bool_tTObject::IsSortable() const
Bool_tTObject::IsZombie() const
virtual voidTNamed::ls(Option_t* option = "") const
virtual voidTObject::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
virtual Bool_tTObject::Notify()
voidOpenFortranFile(int lun, char* name)
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
TNamed&TNamed::operator=(const TNamed& rhs)
TObject&TObject::operator=(const TObject& rhs)
virtual voidTGenerator::Paint(Option_t* option = "")
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTNamed::Print(Option_t* option = "") const
virtual voidTObject::Print(Option_t* option = "") const
voidPy1ent(Int_t line, Int_t kf, Double_t pe, Double_t theta, Double_t phi)
intPychge(int kf)
intPycomp(int kf)
voidPyedit(int medit)
voidPyhepc(int mconv)
voidPyinit(char* frame, char* beam, char* target, double wint)
voidPylist(int flag)
doublePymass(int kf)
voidPyname(int kf, char* name)
doublePyr(int idummy)
voidPyrget(int lun, int move)
voidPyrset(int lun, int move)
voidPystat(int flag)
voidPytest(int flag)
voidPytune(int itune)
voidPyupda(int mupda, int lun)
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidSetBRAT(int i, double b)
voidSetCKIN(int i, double c)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidSetIMSS(int i, int m)
voidSetK(int ip, int i, int k)
voidSetKCHG(int ip, int i, int k)
voidSetKFDP(int i, int j, int k)
voidSetKFIN(int i, int j, Int_t kfin = 1)
voidSetMDCY(int i, int j, int m)
voidSetMDME(int i, int j, int m)
voidSetMINT(int i, int m)
voidSetMRPY(int i, int m)
voidSetMSEL(int m)
voidSetMSELPD(int m)
voidSetMSTI(int i, int m)
voidSetMSTJ(int i, int m)
voidSetMSTP(int i, int m)
voidSetMSTU(int i, int m)
voidSetMSUB(int i, int m)
voidSetMWID(int i, int m)
voidSetN(int n)
virtual voidTNamed::SetName(const char* name)MENU
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
voidSetNGENPD(int n)
voidSetNPAD(int n)
static voidTObject::SetObjectStat(Bool_t stat)
voidSetP(int ip, int i, double p)
virtual voidTGenerator::SetParameter(const char*, Double_t)
voidSetPARF(int i, double p)
voidSetPARI(int i, double p)
voidSetPARJ(int i, double p)
voidSetPARP(int i, double p)
voidSetPARU(int i, double p)
voidSetPMAS(int ip, int i, double m)
virtual voidTGenerator::SetPtCut(Float_t ptcut = 0)MENU
voidSetRMSS(int i, double r)
voidSetRRPY(int i, double r)
voidSetSMW(int i, double s)
voidSetSMZ(int i, double s)
virtual voidTNamed::SetTitle(const char* title = "")MENU
voidSetUMIX(int i, int j, double u)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidSetV(int ip, int i, double v)
voidSetVCKM(int i, int j, double v)
virtual voidTGenerator::SetViewRadius(Float_t rbox = 1000)MENU
virtual voidTGenerator::SetViewRange(Float_t xmin = -10000, Float_t ymin = -10000, Float_t zmin = -10000, Float_t xmax = 10000, Float_t ymax = 10000, Float_t zmax = 10000)MENU
voidSetVINT(int i, double v)
voidSetWIDS(int i, int j, double w)
voidSetZMIX(int i, int j, double z)
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual voidTGenerator::ShowMembers(TMemberInspector& insp, char* parent)
virtual voidTNamed::ShowMembers(TMemberInspector& insp, char* parent)
virtual voidTObject::ShowMembers(TMemberInspector& insp, char* parent)
virtual voidTGenerator::ShowNeutrons(Bool_t show = 1)MENU
virtual Int_tTNamed::Sizeof() const
virtual voidStreamer(TBuffer& b)
virtual voidTGenerator::Streamer(TBuffer& b)
virtual voidTNamed::Streamer(TBuffer& b)
virtual voidTObject::Streamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
voidTGenerator::StreamerNVirtual(TBuffer& b)
voidTNamed::StreamerNVirtual(TBuffer& b)
voidTObject::StreamerNVirtual(TBuffer& b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
TPythia6(const TPythia6&)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
TPythia6&operator=(const TPythia6&)
TGenerator&TGenerator::operator=(const TGenerator& tg)

Data Members

TStringTNamed::fNameobject identifier
TObjArray*TGenerator::fParticles->static container of the primary particles
Float_tTGenerator::fPtCut!Pt cut. Do not show primaries below
Bool_tTGenerator::fShowNeutrons!display neutrons if true
TStringTNamed::fTitleobject title
static TPythia6*fgInstance

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

 TPythia6 constructor: creates a TClonesArray in which it will store all
 particles. Note that there may be only one functional TPythia6 object
 at a time, so it's not use to create more than one instance of it.
TPythia6(const TPythia6& )
{ }
 Destroys the object, deletes and disposes all TMCParticles currently on list.
TPythia6* Instance()
 model of automatic memory cleanup suggested by Jim Kowalkovski:
 destructor for local static variable `cleaner' is  always called in the end
 of the job thus deleting the only TPythia6 instance
void GenerateEvent()
  generate event and copy the information from /HEPEVT/ to fPrimaries
void OpenFortranFile(int lun, char* name)
interface with fortran i/o
void CloseFortranFile(int lun)
interface with fortran i/o
TObjArray * ImportParticles(Option_t* option = "")
 Fills TObjArray fParticles list with particles from common LUJETS
 Old contents of a list are cleared. This function should be called after
 any change in common LUJETS, however GetParticles() method  calls it
 automatically - user don't need to care about it. In case you make a call
 to LuExec() you must call this method yourself to transfer new data from
 common LUJETS to the fParticles list.
Int_t ImportParticles(TClonesArray* particles, Option_t* option = "")
  Default primary creation method. It reads the /HEPEVT/ common block which
  has been filled by the GenerateEvent method. If the event generator does
  not use the HEPEVT common block, This routine has to be overloaded by
  the subclasses.
  The function loops on the generated particles and store them in
  the TClonesArray pointed by the argument particles.
  The default action is to store only the stable particles (ISTHEP = 1)
  This can be demanded explicitly by setting the option = "Final"
  If the option = "All", all the particles are stored.

void Initialize(const char* frame, const char* beam, const char* target, float win)
 Calls PyInit with the same parameters after performing some checking,
 sets correct title. This method should preferably be called instead of PyInit.
 PURPOSE: to initialize the generation procedure.
 ARGUMENTS: See documentation for details.
    frame:  - specifies the frame of the experiment:
    target: - beam and target particles (with additionaly cahrges, tildes or "bar":
    win:    - related to energy system:
              for frame=="CMS" - total energy of system
              for frame=="FIXT" - momentum of beam particle
              for frame=="USER" - dummy - see documentation.
void Pyinit(char* frame, char* beam, char* target, double wint)
 Calls Pyinit with the same parameters after performing some checking,
 sets correct title. This method should preferably be called instead of PyInit.
 PURPOSE: to initialize the generation procedure.
 ARGUMENTS: See documentation for details.
    frame:  - specifies the frame of the experiment:
    target: - beam and target particles (with additionaly charges,
              tildes or "bar":
    win:    - related to energy system:
              for frame=="CMS" - total energy of system
              for frame=="FIXT" - momentum of beam particle
              for frame=="USER" - dummy - see documentation.
int Pycomp(int kf)
interface with fortran routine pycomp
void Pyedit(int medit)
interface with fortran routine pyedit
void Pydiff()
interface with fortran routine pydiff
void Pyevnt()
interface with fortran routine pyevnt
void Pyexec()
interface with fortran routine pyexec
void Pyhepc(int mconv)
interface with fortran routine pyhepc
void Pylist(int flag)
interface with fortran routine pylist
void Pyname(int kf, char* name)
Note that the array name must be dimensioned in the calling program
to at least name[16]
double Pyr(int idummy)
interface with fortran routine pyr
void Pyrget(int lun, int move)
interface with fortran routine pyrget
void Pyrset(int lun, int move)
interface with fortran routine pyrset
void Pystat(int flag)
interface with fortran routine pystat
void Pytest(int flag)
interface with fortran routine pytest
void Pytune(int itune)
interface with fortran routine pytune
void Pyupda(int mupda, int lun)
interface with fortran routine pyupda
double Pymass(int kf)
interface with fortran routine pymass
int Pychge(int kf)
interface with fortran routine pychge
void Py1ent(Int_t line, Int_t kf, Double_t pe, Double_t theta, Double_t phi)
 Add one entry to the event record, i.e. either a parton or a

  IP:   normally line number for the parton/particle. There are two

        If IP = 0: line number 1 is used and PYEXEC is called.
        If IP < 0: line -IP is used, with status code K(-IP,2)=2
                   rather than 1; thus a parton system may be built
                   up by filling all but the last parton of the
                   system with IP < 0.
  KF:   parton/particle flavour code (PDG code)
  PE:   parton/particle energy. If PE is smaller than the mass,
        the parton/particle is taken to be at rest.
  PHI:  polar and azimuthal angle for the momentum vector of the
void SetupTest()
 Exemplary setup of Pythia parameters:
 Switches on processes 102,123,124 (Higgs generation) and switches off
 interactions, fragmentation, ISR, FSR...
TPythia6& operator=(const TPythia6& )
Pyjets_t* GetPyjets()
 ****** accessors
 FORTRAN indexing in accessing the arrays,
 indices start from 1 !!!!!
 ****** access to PYTHIA6 common-blocks
 ****** /PYJETS
{ return fPyjets; }
int GetN()
{ return fPyjets->N; }
int GetNPAD()
{ return fPyjets->NPAD; }
int GetK(int ip, int i)
{ return fPyjets->K[i-1][ip-1]; }
double GetP(int ip, int i)
{ return fPyjets->P[i-1][ip-1]; }
double GetV(int ip, int i)
{ return fPyjets->V[i-1][ip-1]; }
void SetN(int n)
{ fPyjets->N = n; }
void SetNPAD(int n)
{ fPyjets->NPAD = n; }
void SetK(int ip, int i, int k)
{ fPyjets->K[i-1][ip-1] = k; }
void SetP(int ip, int i, double p)
{ fPyjets->P[i-1][ip-1] = p; }
void SetV(int ip, int i, double v)
{ fPyjets->V[i-1][ip-1] = v; }
Pydat1_t* GetPydat1()
 ****** /PYDAT1
{ return fPydat1; }
int GetMSTU(int i)
{ return fPydat1->MSTU[i-1]; }
double GetPARU(int i)
{ return fPydat1->PARU[i-1]; }
int GetMSTJ(int i)
{ return fPydat1->MSTJ[i-1]; }
double GetPARJ(int i)
{ return fPydat1->PARJ[i-1]; }
void SetMSTU(int i, int m)
{ fPydat1->MSTU[i-1] = m; }
void SetPARU(int i, double p)
{ fPydat1->PARU[i-1] = p; }
void SetMSTJ(int i, int m)
{ fPydat1->MSTJ[i-1] = m; }
void SetPARJ(int i, double p)
{ fPydat1->PARJ[i-1] = p; }
Pydat2_t* GetPydat2()
 ****** /PYDAT2
{ return fPydat2; }
int GetKCHG(int ip, int i)
{ return fPydat2->KCHG[i-1][ip-1]; }
double GetPMAS(int ip, int i)
{ return fPydat2->PMAS[i-1][ip-1]; }
double GetPARF(int i)
{ return fPydat2->PARF[i-1]; }
double GetVCKM(int i, int j)
{ return fPydat2->VCKM[j-1][i-1]; }
void SetKCHG(int ip, int i, int k)
{ fPydat2->KCHG[i-1][ip-1] = k; }
void SetPMAS(int ip, int i, double m)
{ fPydat2->PMAS[i-1][ip-1] = m; }
void SetPARF(int i, double p)
{ fPydat2->PARF[i-1] = p; }
void SetVCKM(int i, int j, double v)
{ fPydat2->VCKM[j-1][i-1] = v; }
Pydat3_t* GetPydat3()
 ****** /PYDAT3
{ return fPydat3; }
int GetMDCY(int i, int j)
{ return fPydat3->MDCY[j-1][i-1]; }
int GetMDME(int i, int j)
{ return fPydat3->MDME[j-1][i-1]; }
double GetBRAT(int i)
{ return fPydat3->BRAT[i-1]; }
int GetKFDP(int i, int j)
{ return fPydat3->KFDP[j-1][i-1]; }
void SetMDCY(int i, int j, int m)
{ fPydat3->MDCY[j-1][i-1] = m; }
void SetMDME(int i, int j, int m)
{ fPydat3->MDME[j-1][i-1] = m; }
void SetBRAT(int i, double b)
{ fPydat3->BRAT[i-1] = b; }
void SetKFDP(int i, int j, int k)
{ fPydat3->KFDP[j-1][i-1] = k; }
Pydat4_t* GetPydat4()
 ****** /PYDAT4
{ return fPydat4; }
Pydatr_t* GetPydatr()
 ****** /PYDATR/ - random number generator info
{ return fPydatr; }
int GetMRPY(int i)
{ return fPydatr->MRPY[i-1]; }
double GetRRPY(int i)
{ return fPydatr->RRPY[i-1]; }
void SetMRPY(int i, int m)
{ fPydatr->MRPY[i-1] = m; }
void SetRRPY(int i, double r)
{ fPydatr->RRPY[i-1] = r; }
Pysubs_t* GetPysubs()
 ****** /PYSUBS
{ return fPysubs; }
int GetMSEL()
{ return fPysubs->MSEL; }
int GetMSELPD()
{ return fPysubs->MSELPD; }
int GetMSUB(int i)
{ return fPysubs->MSUB[i-1]; }
double GetCKIN(int i)
{ return fPysubs->CKIN[i-1]; }
Int_t GetKFIN(int i, int j)
{return fPysubs->KFIN[j+40][i-1]; }
void SetMSEL(int m)
{ fPysubs->MSEL = m; }
void SetMSELPD(int m)
{ fPysubs->MSELPD = m; }
void SetMSUB(int i, int m)
{ fPysubs->MSUB[i-1] = m; }
void SetCKIN(int i, double c)
{ fPysubs->CKIN[i-1] = c; }
void SetKFIN(int i, int j, Int_t kfin = 1)
{ fPysubs->KFIN[j+40][i-1] = kfin; }
Pypars_t* GetPypars()
 ****** /PYPARS
{ return fPypars; }
int GetMSTP(int i)
{ return fPypars->MSTP[i-1]; }
double GetPARP(int i)
{ return fPypars->PARP[i-1]; }
int GetMSTI(int i)
{ return fPypars->MSTI[i-1]; }
double GetPARI(int i)
{ return fPypars->PARI[i-1]; }
void SetMSTP(int i, int m)
{ fPypars->MSTP[i-1] = m; }
void SetPARP(int i, double p)
{ fPypars->PARP[i-1] = p; }
void SetMSTI(int i, int m)
{ fPypars->MSTI[i-1] = m; }
void SetPARI(int i, double p)
{ fPypars->PARI[i-1] = p; }
Pyint1_t* GetPyint1()
 ****** /PYINT1
{ return fPyint1; }
int GetMINT(int i)
{ return fPyint1->MINT[i-1]; }
double GetVINT(int i)
{ return fPyint1->VINT[i-1]; }
void SetMINT(int i, int m)
{ fPyint1->MINT[i-1] = m; }
void SetVINT(int i, double v)
{ fPyint1->VINT[i-1] = v; }
Pyint2_t* GetPyint2()
 ****** /PYINT2/ and /PYINT3
{ return fPyint2; }
Pyint3_t* GetPyint3()
{ return fPyint3; }
Pyint4_t* GetPyint4()
 ****** /PYINT4
{ return fPyint4; }
int GetMWID(int i)
{ return fPyint4->MWID[i-1]; }
double GetWIDS(int i, int j)
{ return fPyint4->WIDS[j-1][i-1]; }
void SetMWID(int i, int m)
{ fPyint4->MWID[i-1] = m; }
void SetWIDS(int i, int j, double w)
{ fPyint4->WIDS[j-1][i-1] = w; }
Pyint5_t* GetPyint5()
 ****** / PYINT5
{ return fPyint5; }
int GetNGENPD()
{ return fPyint5->NGENPD; }
void SetNGENPD(int n)
{ fPyint5->NGENPD = n; }
Pyint6_t* GetPyint6()
 ****** /PYINT6
{ return fPyint6; }
char* GetPROC(int i)
{ fPyint6->PROC[i][27]=0; return fPyint6->PROC[i]; }
Pyint7_t* GetPyint7()
{ return fPyint7; }
Pyint8_t* GetPyint8()
{ return fPyint8; }
Pyint9_t* GetPyint9()
{ return fPyint9; }
Pymssm_t* GetPymssm()
 ****** /PYMSSM/ - indexing in FORTRAN starts
 from 0!
{ return fPymssm; }
int GetIMSS(int i)
{ return fPymssm->IMSS[i]; }
double GetRMSS(int i)
{ return fPymssm->RMSS[i]; }
void SetIMSS(int i, int m)
{ fPymssm->IMSS[i] = m; }
void SetRMSS(int i, double r)
{ fPymssm->RMSS[i] = r; }
Pyssmt_t* GetPyssmt()
 ****** /PYSSMT
{ return fPyssmt; }
double GetZMIX(int i, int j)
{ return fPyssmt->ZMIX[j-1][i-1]; }
double GetUMIX(int i, int j)
{ return fPyssmt->UMIX[j-1][i-1]; }
double GetVMIX(int i, int j)
{ return fPyssmt->VMIX[j-1][i-1]; }
double GetSMZ(int i)
{ return fPyssmt->SMZ[i-1]; }
double GetSMW(int i)
{ return fPyssmt->SMW[i-1]; }
void SetZMIX(int i, int j, double z)
{ fPyssmt->ZMIX[j-1][i-1] = z; }
void SetUMIX(int i, int j, double u)
{ fPyssmt->UMIX[j-1][i-1] = u; }
void SetSMZ(int i, double s)
{ fPyssmt->SMZ[i-1] = s; }
void SetSMW(int i, double s)
{ fPyssmt->SMW[i-1] = s; }
Pyints_t* GetPyints()
{ return fPyints; }
Pybins_t* GetPybins()
{ return fPybins; }