// @(#)root/pythia6:$Name: V00-00-40 $:$Id: TG3Pythia6.cc,v 1.4 2003/12/15 22:13:21 murat Exp $ // Author: Rene Brun 19/10/99 // //////////////////////////////////////////////////////////////////////////////// // // // TG3Pythia6 // // // // TPythia is an interface class to F77 version of Pythia 6.1 // // CERNLIB event generators, written by T.Sjostrand. // // For the details about these generators look at Pythia/Jetset manual: // // // //****************************************************************************** //** ** //** ** //** PPP Y Y TTTTT H H III A JJJJ EEEE TTTTT SSS EEEE TTTTT ** //** 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: torbjorn@thep.lu.se ** //** !! e+e- !! ** //** !! !! Copyright Torbjorn Sjostrand ** //** !! and CERN, Geneva 1993 ** //** ** //** ** //** The latest program versions and documentation is found on WWW address ** //** http://thep.lu.se/tf2/staff/torbjorn/Welcome.html ** //** ** //** 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. ** //** ** //** ** //****************************************************************************** // what needs to be changed: // - all the "T" MC generators should output the same format, which would // include event weight, generator code, and a list of TParticles's, // anything else shoudl be an option // - TGenerator needs Initialize and GenerateEvent functions, also output // #include "TClonesArray.h" #include "TParticle.h" #include "TG3Pythia6.hh" #include "TPrimaryInteraction.hh" TG3Pythia6* TG3Pythia6::fgInstance = 0; ClassImp(TG3Pythia6) extern "C" { void* pythia6_common_block_address_(char*, int len); void tpythia6_open_fortran_file_ (int* lun, char* name, int); void tpythia6_close_fortran_file_ (int* lun); void pdfset_ (char* name, double* value); void structm_(double* x , double* q2 , double* uval, double* dval, double* usea, double* dsea, double* str , double* chm , double* bot , double* top , double* glu); void structp_(double* x , double* q2 , double* p2 , double* ip2 , double* uval, double* dval, double* usea, double* dsea, double* str , double* chm , double* bot , double* top , double* glu); void mrst2003c_(double* x , double* q , int* mode, double* uval, double* dval, double* usea, double* dsea, double* str , double* chm , double* bot , double* glu); } //------------------------------------------------------------------------------ TG3Pythia6::Cleaner::Cleaner() { } //------------------------------------------------------------------------------ TG3Pythia6::Cleaner::~Cleaner() { if (TG3Pythia6::fgInstance) { delete TG3Pythia6::fgInstance; TG3Pythia6::fgInstance = 0; } } //------------------------------------------------------------------------------ // constructor is not supposed to be called from the outside - only // Initialize() method //------------------------------------------------------------------------------ TG3Pythia6::TG3Pythia6() { // TG3Pythia6 constructor: creates a TClonesArray in which it will store all // particles. Note that there may be only one functional TG3Pythia6 object // at a time, so it's not use to create more than one instance of it. delete fParticles; // was allocated as TObjArray in TGenerator fParticles = new TClonesArray("TParticle",50); // initialize common-blocks fPyjets = (Pyjets_t*) pythia6_common_block_address_((char*)"PYJETS",6); fPydat1 = (Pydat1_t*) pythia6_common_block_address_((char*)"PYDAT1",6); fPydat2 = (Pydat2_t*) pythia6_common_block_address_((char*)"PYDAT2",6); fPydat3 = (Pydat3_t*) pythia6_common_block_address_((char*)"PYDAT3",6); fPydat4 = (Pydat4_t*) pythia6_common_block_address_((char*)"PYDAT4",6); fPydatr = (Pydatr_t*) pythia6_common_block_address_((char*)"PYDATR",6); fPysubs = (Pysubs_t*) pythia6_common_block_address_((char*)"PYSUBS",6); fPypars = (Pypars_t*) pythia6_common_block_address_((char*)"PYPARS",6); fPyint1 = (Pyint1_t*) pythia6_common_block_address_((char*)"PYINT1",6); fPyint2 = (Pyint2_t*) pythia6_common_block_address_((char*)"PYINT2",6); fPyint3 = (Pyint3_t*) pythia6_common_block_address_((char*)"PYINT3",6); fPyint4 = (Pyint4_t*) pythia6_common_block_address_((char*)"PYINT4",6); fPyint5 = (Pyint5_t*) pythia6_common_block_address_((char*)"PYINT5",6); fPyint6 = (Pyint6_t*) pythia6_common_block_address_((char*)"PYINT6",6); fPyint7 = (Pyint7_t*) pythia6_common_block_address_((char*)"PYINT7",6); fPyint8 = (Pyint8_t*) pythia6_common_block_address_((char*)"PYINT8",6); fPyint9 = (Pyint9_t*) pythia6_common_block_address_((char*)"PYINT9",6); // fPyuppr = (Pyuppr_t*) pythia6_common_block_address_((char*)"PYUPPR",6); fPymssm = (Pymssm_t*) pythia6_common_block_address_((char*)"PYMSSM",6); fPyssmt = (Pyssmt_t*) pythia6_common_block_address_((char*)"PYSSMT",6); fPyints = (Pyints_t*) pythia6_common_block_address_((char*)"PYINTS",6); fPybins = (Pybins_t*) pythia6_common_block_address_((char*)"PYBINS",6); // we also need to set the name such that it // would have Pythia version in it char name[100], title[100]; sprintf(name,"Pythia_%i_%i",GetMSTP(181),GetMSTP(182)); sprintf(title,"Pythia version %i.%i",GetMSTP(181),GetMSTP(182)); SetName(name); SetTitle(title); } //------------------------------------------------------------------------------ TG3Pythia6::~TG3Pythia6() { // Destroys the object, deletes and disposes all TMCParticles currently on list. if (fParticles) { fParticles->Delete(); delete fParticles; fParticles = 0; } } //------------------------------------------------------------------------------ TG3Pythia6* TG3Pythia6::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 TG3Pythia6 instance static TG3Pythia6::Cleaner cleaner; return fgInstance ? fgInstance : (fgInstance=new TG3Pythia6()) ; } //______________________________________________________________________________ Int_t TG3Pythia6::GenerateEvent(TPrimaryInteraction* pi) { // generate event and copy the information from /HEPEVT/ to fPrimaries pyevnt_(); pi->SetName(GetName()); pi->SetWeight(1.); ImportParticles(pi->ParticleList(),"All"); return 0; } //_____________________________________________________________________________ Double_t TG3Pythia6::CrossSection() { // return cross-section corresponding to the events generated so far return GetXSEC(0,3); } //______________________________________________________________________________ void TG3Pythia6::OpenFortranFile(int lun, char* name) { tpythia6_open_fortran_file_(&lun, name, strlen(name)); } //______________________________________________________________________________ void TG3Pythia6::CloseFortranFile(int lun) { tpythia6_close_fortran_file_(&lun); } //_____________________________________________________________________________ Int_t TG3Pythia6::PrintStat(Int_t Flag) { pystat_(&Flag); return 0; } //______________________________________________________________________________ TObjArray *TG3Pythia6::ImportParticles(Option_t *) { // 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. fParticles->Clear(); Int_t numpart = fPyjets->N; TClonesArray* a = (TClonesArray*) fParticles; for (Int_t i = 0; iK[1][i] , fPyjets->K[0][i] , fPyjets->K[2][i] , -1, fPyjets->K[3][i] , fPyjets->K[4][i] , fPyjets->P[0][i] , fPyjets->P[1][i] , fPyjets->P[2][i] , fPyjets->P[3][i] , fPyjets->V[0][i] , fPyjets->V[1][i] , fPyjets->V[2][i] , fPyjets->V[3][i]); } return fParticles; } //______________________________________________________________________________ Int_t TG3Pythia6::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. // if (Particles == 0) return 0; Particles->Clear(); Int_t numpart = fPyjets->N; if (!strcmp(Option,"") || !strcmp(Option,"Final")) { // in this "compressed" mode event history // is not traceable Int_t ipart = 0; for (Int_t i = 0; iK[1][i] == 1) { // // Use the common block values for the TParticle constructor // new((*Particles)[ipart++]) TParticle(fPyjets->K[1][i] , fPyjets->K[0][i] , fPyjets->K[2][i] , -1, fPyjets->K[3][i] , fPyjets->K[4][i] , fPyjets->P[0][i] , fPyjets->P[1][i] , fPyjets->P[2][i] , fPyjets->P[3][i] , fPyjets->V[0][i] , fPyjets->V[1][i] , fPyjets->V[2][i] , fPyjets->V[3][i]); } } numpart = ipart; } else if (!strcmp(Option,"All")) { for (Int_t i = 0; iK[1][i] , fPyjets->K[0][i] , fPyjets->K[2][i] , -1, fPyjets->K[3][i] , fPyjets->K[4][i] , fPyjets->P[0][i] , fPyjets->P[1][i] , fPyjets->P[2][i] , fPyjets->P[3][i] , fPyjets->V[0][i] , fPyjets->V[1][i] , fPyjets->V[2][i] , fPyjets->V[3][i]); } } return numpart; } //______________________________________________________________________________ Int_t TG3Pythia6::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: // "CMS","FIXT","USER","FOUR","FIVE","NONE" // beam, // target: - beam and target particles (with additionaly cahrges, tildes or "bar": // e,nu_e,mu,nu_mu,tau,nu_tau,gamma,pi,n,p,Lambda,Sigma,Xi,Omega, // pomeron,reggeon // 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. //////////////////////////////////////////////////////////////////////////////////// char cframe[4]; strncpy(cframe,frame,4); char cbeam[8]; strncpy(cbeam,beam,8); char ctarget[8]; strncpy(ctarget,target,8); if ( (!strncmp(frame, "CMS" ,3)) && (!strncmp(frame, "FIXT" ,4)) && (!strncmp(frame, "USER" ,4)) && (!strncmp(frame, "FOUR" ,4)) && (!strncmp(frame, "FIVE" ,4)) && (!strncmp(frame, "NONE" ,4)) ) { printf("WARNING! In TG3Pythia6:Initialize():\n"); printf(" specified frame=%s is neither of CMS,FIXT,USER,FOUR,FIVE,NONE\n",frame); printf(" resetting to \"CMS\" ."); sprintf(cframe,"CMS"); } if ( (!strncmp(beam, "e" ,1)) && (!strncmp(beam, "nu_e" ,4)) && (!strncmp(beam, "mu" ,2)) && (!strncmp(beam, "nu_mu" ,5)) && (!strncmp(beam, "tau" ,3)) && (!strncmp(beam, "nu_tau" ,6)) && (!strncmp(beam, "gamma" ,5)) && (!strncmp(beam, "pi" ,2)) && (!strncmp(beam, "n" ,1)) && (!strncmp(beam, "p" ,1)) && (!strncmp(beam, "Lambda" ,6)) && (!strncmp(beam, "Sigma" ,5)) && (!strncmp(beam, "Xi" ,2)) && (!strncmp(beam, "Omega" ,5)) && (!strncmp(beam, "pomeron" ,7)) && (!strncmp(beam, "reggeon" ,7)) ) { printf("WARNING! In TG3Pythia6:Initialize():\n"); printf(" specified beam=%s is unrecognized .\n",beam); printf(" resetting to \"p+\" ."); sprintf(cbeam,"p+"); } if ( (!strncmp(target, "e" ,1)) && (!strncmp(target, "nu_e" ,4)) && (!strncmp(target, "mu" ,2)) && (!strncmp(target, "nu_mu" ,5)) && (!strncmp(target, "tau" ,3)) && (!strncmp(target, "nu_tau" ,6)) && (!strncmp(target, "gamma" ,5)) && (!strncmp(target, "pi" ,2)) && (!strncmp(target, "n" ,1)) && (!strncmp(target, "p" ,1)) && (!strncmp(target, "Lambda" ,6)) && (!strncmp(target, "Sigma" ,5)) && (!strncmp(target, "Xi" ,2)) && (!strncmp(target, "Omega" ,5)) && (!strncmp(target, "pomeron" ,7)) && (!strncmp(target, "reggeon" ,7)) ){ printf("WARNING! In TG3Pythia6:Initialize():\n"); printf(" specified target=%s is unrecognized.\n",target); printf(" resetting to \"p+\" ."); sprintf(ctarget,"p+"); } Pyinit(cframe, cbeam ,ctarget, win); char atitle[32]; sprintf(atitle," %s-%s at %g GeV",cbeam,ctarget,win); SetTitle(atitle); return 0; } //_____________________________________________________________________________ void TG3Pythia6::Pyinit(char* frame, char* beam, char* target, double 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: // "CMS","FIXT","USER","FOUR","FIVE","NONE" // beam, // target: - beam and target particles (with additionaly charges, // tildes or "bar": // e,nu_e,mu,nu_mu,tau,nu_tau,gamma,pi,n,p,Lambda,Sigma,Xi,Omega, // pomeron,reggeon // 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. pyinit_(frame,beam,target,&win,strlen(frame),strlen(beam),strlen(target)); } //_____________________________________________________________________________ int TG3Pythia6::Pycomp(int kf) { return pycomp_(&kf); } //_____________________________________________________________________________ void TG3Pythia6::Pyedit(int medit) { pyedit_(&medit); } void TG3Pythia6::Pyevnt() { pyevnt_(); } void TG3Pythia6::Pyexec() { pyexec_(); } void TG3Pythia6::Pyhepc(int mconv) { pyhepc_(&mconv); } void TG3Pythia6::Pylist(int flag) { pylist_(&flag); } void TG3Pythia6::Pylogo() { pylogo_(); } void TG3Pythia6::Pyname(int kf, char* name) { pyname_(&kf,name,15); // cut trailing blanks to get C string for (int i=15; (i>=0) && (name[i] != ' '); i--) { name[i] = 0; } } double TG3Pythia6::Pyr(int idummy) { return pyr_(&idummy); } void TG3Pythia6::Pyrget(int lun, int move) { pyrget_(&lun,&move); } void TG3Pythia6::Pyrset(int lun, int move) { pyrset_(&lun,&move); } void TG3Pythia6::Pystat(int flag) { pystat_(&flag); } void TG3Pythia6::Pytest(int flag) { pytest_(&flag); } void TG3Pythia6::Pyupda(int mupda, int lun) { pyupda_(&mupda,&lun); } //______________________________________________________________________________ void TG3Pythia6::SetupTest() { // Exemplary setup of Pythia parameters: // Switches on processes 102,123,124 (Higgs generation) and switches off // interactions, fragmentation, ISR, FSR... SetMSEL(0); // full user controll; SetMSUB(102,1); // g + g -> H0 SetMSUB(123,1); // f + f' -> f + f' + H0 SetMSUB(124,1); // f + f' -> f" + f"' + H0 SetPMAS(6,1,175.0); // mass of TOP SetPMAS(25,1,300); // mass of Higgs SetCKIN(1,290.0); // range of allowed mass SetCKIN(2,310.0); SetMSTP(61, 0); // switch off ISR SetMSTP(71, 0); // switch off FSR SetMSTP(81, 0); // switch off multiple interactions SetMSTP(111, 0); // switch off fragmentation/decay } //_____________________________________________________________________________ int TG3Pythia6::PrintDecayChannels(const char* name) { // print decay channels of a particle with a given name char nm[20]; TG3Pythia6* py = TG3Pythia6::Instance(); for (int kc=0; kcGetMSTU(6); kc++) { int kf = py->GetKCHG(kc,4); // uncompressed particle code py->Pyname(kf,nm); int j; for (j=0; ((j<19) && ((nm[j] != ' '))) ; j++) {} nm[j]=0; if (nm[0] != 0) { if (strcmp(name,nm) == 0) { PrintParticle(kf); return 0; } } } return -1; } //_____________________________________________________________________________ // turn ON/OFF given decay channel for a particle with the given name // decay channels are numbered starting from 1 for a particle - this is // convenient because when a new particle is added to a Pythia particle DB // the global number decay of given decay channel may change while it most // probably will not change if we start counting the channels from the 1st one // for a given particle // input parameters: // ----------------- // flag : 1, 0 or -1 (-1 if the channel should not be accounted for in the // calculation of the full width) //_____________________________________________________________________________ int TG3Pythia6::NDecayChannels(const char* name) { char nm[20]; int nchannels, id1, id2; TG3Pythia6* py = TG3Pythia6::Instance(); for (int kc=0; kcGetMSTU(6); kc++) { int kf = py->GetKCHG(kc,4); py->Pyname(kf,nm); int j; for (j=0; ((j<19) && ((nm[j] != ' '))) ; j++) {} nm[j]=0; if ( (nm[0] != 0) && ( (strcmp(name,nm) == 0))) { id1 = py->GetMDCY(kc,2); id2 = py->GetMDCY(kc,2)+py->GetMDCY(kc,3); nchannels = id2-id1+1; return nchannels; } } return -1; } //_____________________________________________________________________________ int TG3Pythia6::SetDecayChannel(const char* name, int channel, int flag) { char nm[20]; TG3Pythia6* py = TG3Pythia6::Instance(); for (int kc=0; kcGetMSTU(6); kc++) { int kf = py->GetKCHG(kc,4); py->Pyname(kf,nm); int j; for (j=0; ((j<19) && ((nm[j] != ' '))) ; j++) {} nm[j]=0; if ( (nm[0] != 0) && ( (strcmp(name,nm) == 0))) { int id1 = py->GetMDCY(kc,2); int id2 = py->GetMDCY(kc,2)+py->GetMDCY(kc,3); int nchannels = id2-id1+1; if (nchannels >= channel) { int idc = id1+channel-1; py->SetMDME(idc,1,flag); return 0; } } } return -1; } //_____________________________________________________________________________ int TG3Pythia6::DecayChannel(const char* Name, int Channel) { char nm[20]; TG3Pythia6* py = TG3Pythia6::Instance(); for (int kc=0; kcGetMSTU(6); kc++) { int kf = py->GetKCHG(kc,4); py->Pyname(kf,nm); int j; for (j=0; ((j<19) && ((nm[j] != ' '))) ; j++) {} nm[j]=0; if ( (nm[0] != 0) && ( (strcmp(Name,nm) == 0))) { int id1 = py->GetMDCY(kc,2); int id2 = py->GetMDCY(kc,2)+py->GetMDCY(kc,3); int nchannels = id2-id1+1; if (nchannels >= Channel) { int idc = id1+Channel-1; return py->GetMDME(idc,1); } } } return -1; } //_____________________________________________________________________________ Int_t TG3Pythia6::PrintParticleNames(const char* Pattern) { // print names of all the particles with a given pattern in a name // known to Pythia TG3Pythia6* py = TG3Pythia6::Instance(); char name[20]; int n = 0; for (int kc=0; kcGetMSTU(6); kc++) { int kf = py->GetKCHG(kc,4); if (kf != 0) { if (kf>py->GetMSTU(1)) { if ((py->GetMSTU(2) <= 0) || (kf <= py->GetMSTU(2))) { for (int j=0; j<20; j++) name[j] = 0; py->Pyname(kf,name); int j; for (j=0; ((j<19) && ((name[j] != ' '))) ; j++) {} name[j]=0; // make sure that name contains pattern in it // (case sensitive) if ( name[0] && ((! Pattern) || (strstr(name,Pattern))) ) { printf("%-16s",name); n++; if (n > 5) { printf("\n"); n = 0; } } } } } } if (n > 0) { printf("\n"); } return 0; } //_____________________________________________________________________________ int TG3Pythia6::PrintParticle(int kf) { // print particle with given code TG3Pythia6* py = TG3Pythia6::Instance(); char name[20]; py->Pyname(kf,name); for (int i=19; ((i>=0) && ((name[i] == ' ') || (name[i] == 0))) ; i--) { name[i] = 0; } printf(" -- particle: %11s , KF = %7i \n",name,kf); int kc = py->Pycomp(kf); int id1 = py->GetMDCY(kc,2); int id2 = py->GetMDCY(kc,2)+py->GetMDCY(kc,3); char nm[5][20]; int ichan = 0; for (int idc=id1; idcGetKFDP(idc,j); py->Pyname(code, nm[j-1]); int k; for (k=0; ((k<190) && ((nm[j-1][k] != ' '))) ; k++) {} nm[j-1][k]=0; } ichan++; printf("%3i %6d %10.3f %10.3f %10.3f %-10s %-10s %-10s %-10s %-10s \n", idc-id1+1, idc, py->GetMDME(idc,1), py->GetMDME(idc,2), py->GetBRAT(idc), nm[0], nm[1], nm[2], nm[3], nm[4]); } return 0; } //_____________________________________________________________________________ void TG3Pythia6::Pdfset(const char* Name, Double_t Value) { char name[20][20]; double value[20]; for (int i=0; i<20; i++) { if (i == 0) { for (int j=0; ((j < 20) && (Name[j] != 0)); j++) { name[0][j] = Name[j]; } } else { for (int j=0; j<20; j++) { name[i][j] = ' '; } } } value[0] = Value; pdfset_((char*)name,value); } //_____________________________________________________________________________ void TG3Pythia6::Structm(Double_t X, Double_t Q2 , Double_t& UVal, Double_t& DVal, Double_t& USea, Double_t& DSea, Double_t& Str , Double_t& Chm , Double_t& Bot , Double_t& Top , Double_t& Glu) { structm_(&X,&Q2,&UVal,&DVal,&USea,&DSea,&Str,&Chm,&Bot,&Top,&Glu); } //_____________________________________________________________________________ void TG3Pythia6::Structp(Double_t X, Double_t Q2 , Double_t P2 , Double_t IP2 , Double_t& UVal, Double_t& DVal, Double_t& USea, Double_t& DSea, Double_t& Str , Double_t& Chm , Double_t& Bot , Double_t& Top , Double_t& Glu) { structp_(&X,&Q2,&P2,&IP2,&UVal,&DVal,&USea,&DSea,&Str,&Chm,&Bot,&Top,&Glu); } //_____________________________________________________________________________ void TG3Pythia6::Mrst2003c(Double_t X, Double_t Q , Int_t Mode, Double_t& UVal, Double_t& DVal, Double_t& USea, Double_t& DSea, Double_t& Str , Double_t& Chm , Double_t& Bot , Double_t& Glu) { // unlike other interfaces, MRST one doesn't have top parameter! mrst2003c_(&X,&Q,&Mode,&UVal,&DVal,&USea,&DSea,&Str,&Chm,&Bot,&Glu); }