HepMC Reference Documentation HepMC

PythiaWrapper6_4.h

Go to the documentation of this file.

//--------------------------------------------------------------------------
#ifndef PYTHIA_WRAPPER_6_H
#define PYTHIA_WRAPPER_6_H

// Matt.Dobbs@Cern.CH, November 2000
// Version 6.200 update October 2001
// Wrapper for FORTRAN version of Pythia 
// This wrapper is NOT intended as a part of HepMC - it is only supplied
// for your convenience.
// 
// A simple example of calling Pythia from C++ using this header file is
// given in test/test_PythiaWrapper.cxx
//
// Note the pyhepc routine is used by Pythia to fill
// the HEPEVT common block uses double precision and 4000 entries.
//

#include <ctype.h>
#include <cstring>

//--------------------------------------------------------------------------
// Initialization routine


extern "C" {
    void initpydata(void);
}
#define initpydata initpydata_

//--------------------------------------------------------------------------
// PYTHIA Common Block Declarations

const int pyjets_maxn =4000;
extern "C" {
    extern struct {
        int n, npad, k[5][pyjets_maxn];
        double p[5][pyjets_maxn], v[5][pyjets_maxn];
    } pyjets_;
}
#define pyjets pyjets_

extern "C" {
    extern struct {
        int mstu[200];
        double paru[200];
        int mstj[200];
        double parj[200];
    } pydat1_;
}
#define pydat1 pydat1_

extern "C" {
    extern struct {
        int kchg[4][500];
        double pmas[4][500], parf[2000], vckm[4][4];  
    } pydat2_;
}
#define pydat2 pydat2_

extern "C" {
    extern struct {
        int mdcy[3][500], mdme[2][8000];
        double brat[8000];
        int kfdp[5][8000];
    } pydat3_;
}
#define pydat3 pydat3_

extern "C" {
    extern struct {
        int mrpy[6];
        double rrpy[100];
    } pydatr_;
}
#define pydatr pydatr_

extern "C" {
    extern struct {
        int msel, mselpd, msub[500], kfin[81][2];
        double ckin[200];
    } pysubs_;
}
#define pysubs pysubs_

extern "C" {
    extern struct {
        int mstp[200];
        double parp[200];
        int msti[200];
        double pari[200];
    } pypars_;
}
#define pypars pypars_

extern "C" {
    extern struct {
        int mint[400];
        double vint[400];
    } pyint1_;
}
#define pyint1 pyint1_

extern "C" {
    extern struct {
        int iset[500], kfpr[2][500];
        double coef[20][500];
        int icol[2][4][40];
    } pyint2_;
}
#define pyint2 pyint2_

extern "C" {
    extern struct pin3 {
        double xsfx[81][2];     // Fortran is xsfx(2,-40:40)
        int isig[3][1000];
        double sigh[1000];
    } pyint3_;
}
#define pyint3 pyint3_

extern "C" {
    extern struct {
        int mwid[500];
        double wids[5][500];
    } pyint4_;
}
#define pyint4 pyint4_

extern "C" {
    extern struct pin5 {
        int ngenpd, ngen[3][501];       // Fortran is ngen(0:500,3)
        double xsec[3][501];            // Fortran is xsec(0:500,3)
    } pyint5_;
}
#define pyint5 pyint5_

extern "C" {
    extern struct pin7 {
        double sigt[6][7][7];   // Fortran is sigt(0:6,0:6,0:5)
    } pyint7_;
}
#define pyint7 pyint7_

extern "C" {
    extern struct pin8 {
        double xpvmd[13];       // Fortran is xpvmd(-6:6)
        double xpanl[13];       // Fortran is xpanl(-6:6)
        double xpanh[13];       // Fortran is xpanh(-6:6)
        double xpbeh[13];       // Fortran is xpbeh(-6:6)
        double xpdir[13];       // Fortran is xpdir(-6:6)
    } pyint8_;
}
#define pyint8 pyint8_

extern "C" {
    extern struct pin9 {
        double vxpvmd[13];      // Fortran is vxpvmd(-6:6)
        double vxpanl[13];      // Fortran is vxpanl(-6:6)
        double vxpanh[13];      // Fortran is vxpanh(-6:6)
        double vxpdgm[13];      // Fortran is vxpdgm(-6:6)
    } pyint9_;
}
#define pyint9 pyint9_

extern "C" {
    extern struct pssm {
        int imss[100];          // Fortran is imss(0:99)
        double rmss[100];       // Fortran is rmss(0:99)
    } pyssm_;
}
#define pyssm pyssm_

extern "C" {
    extern struct {
        double zmix[4][4];
        double umix[2][2];
        double vmix[2][2];
        double smz[4];
        double smw[2];
        double sfmix[4][16];
        double zmixi[4][4];
        double umixi[2][2];
        double vmixi[2][2];
    } pyssmt_;
}
#define pyssmt pyssmt_

extern "C" {
    extern struct {
        double rvlam[3][3][3];
        double rvlamp[3][3][3];
        double rvlamb[3][3][3];
    } pymsrv_;
}
#define pymsrv pymsrv_

extern "C" {
    extern struct prvnv {
        double ab[2][16][2];
        double rms[4];          // Fortran is rms(0:3)
        double res[5][6];
        int idr;
        int idr2;
        double dcmass;
        int kfr[3];
    } pyrvnv_;
}
#define pyrvnv pyrvnv_

extern "C" {
    extern struct prvpm {
        double rm[4];           // Fortran is rm(0:3)
        double a[2];
        double b[2];
        double resm[2];
        double resw[2];
        bool mflag;
    } pyrvpm_;
}
#define pyrvpm pyrvpm_

extern "C" {
    extern struct {
        double xxm[20];
    } pyints_;
}
#define pyints pyints_

extern "C" {
    extern struct {
        double x1;
    } pyg2dx_;
}
#define pyg2dx pyg2dx_

//--------------------------------------------------------------------------
// PYTHIA routines declaration

#define pyhepc pyhepc_ 
#define pyinit pyinit_
#define pylist pylist_
#define pystat pystat_
#define pyevnt pyevnt_
#define upinit upinit_
#define upevnt upevnt_
    extern "C" {
        void pyhepc(int*);
        void pyinit(const char*,const char*,const char*,double*,int,int,int);
        void pylist(int*);
        void pystat(int*);
        void pyevnt();
        void upinit();
        void upevnt();
    }

// define methods to hide the subtle syntax necessary to call fortran from C++
inline void call_pyhepc( int mode ){ pyhepc( &mode ); }
inline void call_pyinit( const char* frame, const char* beam, const char* target,
                  double win ) 
{ pyinit( frame,beam,target,&win,strlen(frame),strlen(beam),strlen(target) ); }
inline void call_pylist( int mode ){ pylist( &mode ); }
inline void call_pystat( int mode ){ pystat( &mode ); }
inline void call_pyevnt(){ pyevnt(); }


//--------------------------------------------------------------------------
// PYTHIA block data
// ( with gcc it works to initialize the block data by calling 
//   "pydata();" at beginning, but this fails for f77, so the fortran routine
//   initpydata.f is supplied ... call it instead for platform independent
//   behaviour )

#define pydata pydata_
extern "C" {
    void pydata(void);
}

#endif  // PYTHIA_WRAPPER_6_H
//--------------------------------------------------------------------------

---