Logo ROOT  
Reference Guide
TPythia6.cxx
Go to the documentation of this file.
1// @(#)root/pythia6:$Id$
2// Author: Rene Brun 19/10/99
3
4/** \class TPythia6
5 \ingroup pythia6
6
7TPythia is an interface class to F77 version of Pythia 6.2
8
9To use this class you must install a version of pythia6.
10See the installation instructions at
11 http://root.cern.ch/root/Install.html
12
13CERNLIB event generators, written by T.Sjostrand.
14For the details about these generators look at Pythia/Jetset manual:
15
16\verbatim
17******************************************************************************
18** **
19** **
20** PPP Y Y TTTTT H H III A JJJJ EEEE TTTTT SSS EEEE TTTTT **
21** P P Y Y T H H I A A J E T S E T **
22** PPP Y T HHHHH I AAAAA J EEE T SSS EEE T **
23** P Y T H H I A A J J E T S E T **
24** P Y T H H III A A JJ EEEE T SSS EEEE T **
25** **
26** **
27** *......* Welcome to the Lund Monte Carlo! **
28** *:::!!:::::::::::* **
29** *::::::!!::::::::::::::* This is PYTHIA version 5.720 **
30** *::::::::!!::::::::::::::::* Last date of change: 29 Nov 1995 **
31** *:::::::::!!:::::::::::::::::* **
32** *:::::::::!!:::::::::::::::::* This is JETSET version 7.408 **
33** *::::::::!!::::::::::::::::*! Last date of change: 23 Aug 1995 **
34** *::::::!!::::::::::::::* !! **
35** !! *:::!!:::::::::::* !! Main author: **
36** !! !* -><- * !! Torbjorn Sjostrand **
37** !! !! !! Dept. of theoretical physics 2 **
38** !! !! !! University of Lund **
39** !! !! Solvegatan 14A **
40** !! ep !! S-223 62 Lund, Sweden **
41** !! !! phone: +46 - 46 - 222 48 16 **
42** !! pp !! E-mail: torbjorn@thep.lu.se **
43** !! e+e- !! **
44** !! !! Copyright Torbjorn Sjostrand **
45** !! and CERN, Geneva 1993 **
46** **
47** **
48** The latest program versions and documentation is found on WWW address **
49** http://thep.lu.se/tf2/staff/torbjorn/Welcome.html **
50** **
51** When you cite these programs, priority should always be given to the **
52** latest published description. Currently this is **
53** T. Sjostrand, Computer Physics Commun. 82 (1994) 74. **
54** The most recent long description (unpublished) is **
55** T. Sjostrand, LU TP 95-20 and CERN-TH.7112/93 (revised August 1995). **
56** Also remember that the programs, to a large extent, represent original **
57** physics research. Other publications of special relevance to your **
58** studies may therefore deserve separate mention. **
59** **
60** **
61******************************************************************************
62\endverbatim
63*/
64
65#include "TPythia6.h"
66
67#include "TClonesArray.h"
68#include "TMCParticle.h"
69#include "TParticle.h"
70#include "snprintf.h"
71#include "strlcpy.h"
72
74
75
76#ifndef WIN32
77# define pydiff pydiff_
78# define pyevnt pyevnt_
79# define pyinit pyinit_
80# define pychge pychge_
81# define pycomp pycomp_
82# define pyedit pyedit_
83# define pyexec pyexec_
84# define pyhepc pyhepc_
85# define pygive pygive_
86# define pylist pylist_
87# define pymass pymass_
88# define pyname pyname_
89# define pyr pyr_
90# define pyrget pyrget_
91# define pyrset pyrset_
92# define pystat pystat_
93# define pytest pytest_
94# define pytune pytune_
95# define pyupda pyupda_
96# define py1ent py1ent_
97# ifdef PYTHIA6_DOUBLE_UNDERSCORE
98# define tpythia6_open_fortran_file tpythia6_open_fortran_file__
99# define tpythia6_close_fortran_file tpythia6_close_fortran_file__
100# define pythia6_common_address pythia6_common_address__
101# elif PYTHIA6_SINGLE_UNDERSCORE
102# define tpythia6_open_fortran_file tpythia6_open_fortran_file_
103# define tpythia6_close_fortran_file tpythia6_close_fortran_file_
104# define pythia6_common_address pythia6_common_address
105# else
106# define pythia6_common_address pythia6_common_address
107# define tpythia6_open_fortran_file tpythia6_open_fortran_file_
108# define tpythia6_close_fortran_file tpythia6_close_fortran_file_
109# endif
110# define type_of_call
111#else
112# define pydiff PYDIFF
113# define pyevnt PYEVNT
114# define pyinit PYINIT
115# define pychge PYCHGE
116# define pycomp PYCOMP
117# define pyedit PYEDIT
118# define pyexec PYEXEC
119# define pygive PYGIVE
120# define pyhepc PYHEPC
121# define pylist PYLIST
122# define pymass PYMASS
123# define pyname PYNAME
124# define pyr PYR
125# define pyrget PYRGET
126# define pyrset PYRSET
127# define pystat PYSTAT
128# define pytest PYTEST
129# define pytune PYTUNE
130# define pyupda PYUPDA
131# define py1ent PY1ENT
132# define tpythia6_open_fortran_file TPYTHIA6_OPEN_FORTRAN_FILE
133# define tpythia6_close_fortran_file TPYTHIA6_CLOSE_FORTRAN_FILE
134# define type_of_call _stdcall
135#endif
136
137
138extern "C" void type_of_call pyevnt();
139extern "C" void type_of_call pystat(int *key);
140extern "C" void type_of_call pylist(int *key);
141extern "C" void type_of_call pyedit(int *medit);
142extern "C" void type_of_call pydiff();
143extern "C" void type_of_call pyexec();
144extern "C" void type_of_call pygive(const char *param, Long_t lparam);
145extern "C" void type_of_call pyhepc(int *mconv);
146extern "C" void type_of_call pylist(int *flag);
147extern "C" int type_of_call pychge(int *kf);
148extern "C" int type_of_call pycomp(int *kf);
149extern "C" double type_of_call pymass(int *kf);
150extern "C" void type_of_call pyname(int *kf, char *name, Long_t l_name);
151extern "C" int type_of_call pyr(int *dummy);
152extern "C" int type_of_call pyrget(int *lun, int *move);
153extern "C" int type_of_call pyrset(int *lun, int *move);
154extern "C" int type_of_call pytest(int *flag);
155extern "C" int type_of_call pytune(int *itune);
156extern "C" int type_of_call pyupda(int *mupda, int *lun);
158
159#ifndef WIN32
160extern "C" void type_of_call pyinit(char *frame, char *beam, char *target,
161 double *win, Long_t l_frame, Long_t l_beam,
162 Long_t l_target);
163#else
164extern "C" void type_of_call pyinit(char *frame, Long_t l_frame,
165 char *beam, Long_t l_beam,
166 char *target, Long_t l_target,
167 double *win
168 );
169#endif
170
171extern "C" {
172 void* pythia6_common_address(const char*);
173 void type_of_call tpythia6_open_fortran_file(int* lun, char* name, int);
175}
176
178
179/** \class TPythia6::TPythia6Cleaner
180 \ingroup pythia6
181
182Utility class to manage the TPythia6 instance
183*/
184
186}
187
188////////////////////////////////////////////////////////////////////////////////
189///delete the TPythia6 insntance
190
195 }
196}
197
198//------------------------------------------------------------------------------
199// constructor is not supposed to be called from the outside - only
200// Initialize() method
201////////////////////////////////////////////////////////////////////////////////
202/// TPythia6 constructor: creates a TClonesArray in which it will store all
203/// particles. Note that there may be only one functional TPythia6 object
204/// at a time, so it's not use to create more than one instance of it.
205
206TPythia6::TPythia6() : TGenerator("TPythia6","TPythia6") {
207 // Protect against multiple objects. All access should be via the
208 // Instance member function.
209 if (fgInstance)
210 Fatal("TPythia6", "There's already an instance of TPythia6");
211
212 delete fParticles; // was allocated as TObjArray in TGenerator
213
214 fParticles = new TClonesArray("TMCParticle",50);
215
216 // initialize common-blocks
217 // the functions/subroutines referenced by TPythia6 can be found
218 // at ftp://root.cern.ch/root/pythia6.tar.gz
219
241}
242
243////////////////////////////////////////////////////////////////////////////////
244
246 TGenerator(p6),
247 fPyjets(p6.fPyjets),
248 fPydat1(p6.fPydat1),
249 fPydat2(p6.fPydat2),
250 fPydat3(p6.fPydat3),
251 fPydat4(p6.fPydat4),
252 fPydatr(p6.fPydatr),
253 fPysubs(p6.fPysubs),
254 fPypars(p6.fPypars),
255 fPyint1(p6.fPyint1),
256 fPyint2(p6.fPyint2),
257 fPyint3(p6.fPyint3),
258 fPyint4(p6.fPyint4),
259 fPyint5(p6.fPyint5),
260 fPyint6(p6.fPyint6),
261 fPyint7(p6.fPyint7),
262 fPyint8(p6.fPyint8),
263 fPyint9(p6.fPyint9),
264 fPymssm(p6.fPymssm),
265 fPyssmt(p6.fPyssmt),
266 fPyints(p6.fPyints),
267 fPybins(p6.fPybins)
268{ }
269
270////////////////////////////////////////////////////////////////////////////////
271/// Destroys the object, deletes and disposes all TMCParticles currently on list.
272
274{
275 if (fParticles) {
277 delete fParticles;
278 fParticles = 0;
279 }
280}
281
282////////////////////////////////////////////////////////////////////////////////
283/// model of automatic memory cleanup suggested by Jim Kowalkovski:
284/// destructor for local static variable `cleaner' is always called in the end
285/// of the job thus deleting the only TPythia6 instance
286
288 static TPythia6::TPythia6Cleaner cleaner;
289 return fgInstance ? fgInstance : (fgInstance=new TPythia6()) ;
290}
291
292
293
294
295
296////////////////////////////////////////////////////////////////////////////////
297/// generate event and copy the information from /HEPEVT/ to fPrimaries
298
300 pyevnt();
302}
303
304////////////////////////////////////////////////////////////////////////////////
305///interface with fortran i/o
306
307void TPythia6::OpenFortranFile(int lun, char* name) {
308 tpythia6_open_fortran_file(&lun, name, strlen(name));
309}
310
311////////////////////////////////////////////////////////////////////////////////
312///interface with fortran i/o
313
316}
317
318
319////////////////////////////////////////////////////////////////////////////////
320/// Fills TObjArray fParticles list with particles from common LUJETS
321/// Old contents of a list are cleared. This function should be called after
322/// any change in common LUJETS, however GetParticles() method calls it
323/// automatically - user don't need to care about it. In case you make a call
324/// to LuExec() you must call this method yourself to transfer new data from
325/// common LUJETS to the fParticles list.
326
328{
329 fParticles->Clear();
330 Int_t numpart = fPyjets->N;
332 for (Int_t i = 0; i<numpart; i++) {
333 new(a[i]) TMCParticle(fPyjets->K[0][i] ,
334 fPyjets->K[1][i] ,
335 fPyjets->K[2][i] ,
336 fPyjets->K[3][i] ,
337 fPyjets->K[4][i] ,
338 fPyjets->P[0][i] ,
339 fPyjets->P[1][i] ,
340 fPyjets->P[2][i] ,
341 fPyjets->P[3][i] ,
342 fPyjets->P[4][i] ,
343 fPyjets->V[0][i] ,
344 fPyjets->V[1][i] ,
345 fPyjets->V[2][i] ,
346 fPyjets->V[3][i] ,
347 fPyjets->V[4][i]);
348 }
349 return fParticles;
350}
351
352////////////////////////////////////////////////////////////////////////////////
353/// Default primary creation method. It reads the /HEPEVT/ common block which
354/// has been filled by the GenerateEvent method. If the event generator does
355/// not use the HEPEVT common block, This routine has to be overloaded by
356/// the subclasses.
357/// The function loops on the generated particles and store them in
358/// the TClonesArray pointed by the argument particles.
359/// The default action is to store only the stable particles (ISTHEP = 1)
360/// This can be demanded explicitly by setting the option = "Final"
361/// If the option = "All", all the particles are stored.
362///
363
365{
366 if (particles == 0) return 0;
367 TClonesArray &clonesParticles = *particles;
368 clonesParticles.Clear();
369 Int_t numpart = fPyjets->N;
370 Int_t nparts=0;
371 if (!strcmp(option,"") || !strcmp(option,"Final")) {
372 for (Int_t i = 0; i<numpart; i++) {
373
374 if (fPyjets->K[0][i] == 1) {
375 //
376 // Use the common block values for the TParticle constructor
377 //
378 new(clonesParticles[nparts]) TParticle(
379 fPyjets->K[1][i] ,
380 fPyjets->K[0][i] ,
381 fPyjets->K[2][i] ,
382 -1,
383 fPyjets->K[3][i] ,
384 fPyjets->K[4][i] ,
385 fPyjets->P[0][i] ,
386 fPyjets->P[1][i] ,
387 fPyjets->P[2][i] ,
388 fPyjets->P[3][i] ,
389 fPyjets->V[0][i] ,
390 fPyjets->V[1][i] ,
391 fPyjets->V[2][i] ,
392 fPyjets->V[3][i]);
393
394 // if(gDebug) printf("%d %d %d! ",i,fPyjets->K[1][i],numpart);
395 nparts++;
396 }
397 }
398 } else if (!strcmp(option,"All")) {
399 for (Int_t i = 0; i<numpart; i++) {
400 new(clonesParticles[i]) TParticle(
401 fPyjets->K[1][i] ,
402 fPyjets->K[0][i] ,
403 fPyjets->K[2][i] ,
404 -1,
405 fPyjets->K[3][i] ,
406 fPyjets->K[4][i] ,
407 fPyjets->P[0][i] ,
408 fPyjets->P[1][i] ,
409 fPyjets->P[2][i] ,
410 fPyjets->P[3][i] ,
411 fPyjets->V[0][i] ,
412 fPyjets->V[1][i] ,
413 fPyjets->V[2][i] ,
414 fPyjets->V[3][i]);
415 }
416 nparts=numpart;
417 }
418
419 return nparts;
420}
421
422////////////////////////////////////////////////////////////////////////////////
423/// Calls PyInit with the same parameters after performing some checking,
424/// sets correct title. This method should preferably be called instead of PyInit.
425/// PURPOSE: to initialize the generation procedure.
426/// ARGUMENTS: See documentation for details.
427/// - frame: - specifies the frame of the experiment:
428/// "CMS","FIXT","USER","FOUR","FIVE","NONE"
429/// - beam,
430/// - target: - beam and target particles (with additionaly charges, tildes or "bar":
431/// e,nu_e,mu,nu_mu,tau,nu_tau,gamma,pi,n,p,Lambda,Sigma,Xi,Omega,
432/// pomeron,reggeon
433/// - win: - related to energy system:
434/// - for frame=="CMS" - total energy of system
435/// - for frame=="FIXT" - momentum of beam particle
436/// - for frame=="USER" - dummy - see documentation.
437
438void TPythia6::Initialize(const char *frame, const char *beam, const char *target, float win)
439{
440 char cframe[4];
441 strlcpy(cframe,frame,4);
442 char cbeam[10];
443 strlcpy(cbeam,beam,10);
444 char ctarget[10];
445 strlcpy(ctarget,target,10);
446
447 // For frames "3MOM", "4MOM" and "5MOM" see p. 181-182 of the version 6 manual,
448 // http://home.thep.lu.se/~torbjorn/pythia/lutp0613man2.pdf
449 // their usage may depend on the version of Pythia6 used
450 if ( (!strncmp(frame, "CMS" ,3)) &&
451 (!strncmp(frame, "FIXT" ,4)) &&
452 (!strncmp(frame, "USER" ,4)) &&
453 (!strncmp(frame, "FOUR" ,4)) &&
454 (!strncmp(frame, "FIVE" ,4)) &&
455 (!strncmp(frame, "3MOM" ,4)) &&
456 (!strncmp(frame, "4MOM" ,4)) &&
457 (!strncmp(frame, "5MOM" ,4)) &&
458 (!strncmp(frame, "NONE" ,4)) ) {
459 printf("WARNING! In TPythia6:Initialize():\n");
460 printf(" specified frame=%s is neither of CMS,FIXT,USER,FOUR,FIVE,NONE,3MOM,4MOM,5MOM\n",frame);
461 printf(" resetting to \"CMS\" .");
462 snprintf(cframe,4,"CMS");
463 }
464
465 if ( (!strncmp(beam, "e" ,1)) &&
466 (!strncmp(beam, "nu_e" ,4)) &&
467 (!strncmp(beam, "mu" ,2)) &&
468 (!strncmp(beam, "nu_mu" ,5)) &&
469 (!strncmp(beam, "tau" ,3)) &&
470 (!strncmp(beam, "nu_tau" ,6)) &&
471 (!strncmp(beam, "gamma" ,5)) &&
472 (!strncmp(beam, "pi" ,2)) &&
473 (!strncmp(beam, "n" ,1)) &&
474 (!strncmp(beam, "p" ,1)) &&
475 (!strncmp(beam, "Lambda" ,6)) &&
476 (!strncmp(beam, "Sigma" ,5)) &&
477 (!strncmp(beam, "Xi" ,2)) &&
478 (!strncmp(beam, "Omega" ,5)) &&
479 (!strncmp(beam, "pomeron" ,7)) &&
480 (!strncmp(beam, "reggeon" ,7)) ) {
481 printf("WARNING! In TPythia6:Initialize():\n");
482 printf(" specified beam=%s is unrecognized .\n",beam);
483 printf(" resetting to \"p+\" .");
484 snprintf(cbeam,8,"p+");
485 }
486
487 if ( (!strncmp(target, "e" ,1)) &&
488 (!strncmp(target, "nu_e" ,4)) &&
489 (!strncmp(target, "mu" ,2)) &&
490 (!strncmp(target, "nu_mu" ,5)) &&
491 (!strncmp(target, "tau" ,3)) &&
492 (!strncmp(target, "nu_tau" ,6)) &&
493 (!strncmp(target, "gamma" ,5)) &&
494 (!strncmp(target, "pi" ,2)) &&
495 (!strncmp(target, "n" ,1)) &&
496 (!strncmp(target, "p" ,1)) &&
497 (!strncmp(target, "Lambda" ,6)) &&
498 (!strncmp(target, "Sigma" ,5)) &&
499 (!strncmp(target, "Xi" ,2)) &&
500 (!strncmp(target, "Omega" ,5)) &&
501 (!strncmp(target, "pomeron" ,7)) &&
502 (!strncmp(target, "reggeon" ,7)) ){
503 printf("WARNING! In TPythia6:Initialize():\n");
504 printf(" specified target=%s is unrecognized.\n",target);
505 printf(" resetting to \"p+\" .");
506 snprintf(ctarget,8,"p+");
507 }
508
509 Pyinit(cframe, cbeam ,ctarget, win);
510
511 char atitle[64];
512 snprintf(atitle, sizeof(atitle)," %s-%s at %g GeV", cbeam, ctarget, win);
513 SetTitle(atitle);
514}
515
516
517void TPythia6::Pyinit(char* frame, char* beam, char* target, double win)
518{
519 // Calls Pyinit with the same parameters after performing some checking,
520 // sets correct title. This method should preferably be called instead of PyInit.
521 // PURPOSE: to initialize the generation procedure.
522 // ARGUMENTS: See documentation for details.
523 // frame: - specifies the frame of the experiment:
524 // "CMS","FIXT","USER","FOUR","FIVE","NONE"
525 // beam,
526 // target: - beam and target particles (with additionaly charges,
527 // tildes or "bar":
528 // e,nu_e,mu,nu_mu,tau,nu_tau,gamma,pi,n,p,Lambda,Sigma,Xi,Omega,
529 // pomeron,reggeon
530 // win: - related to energy system:
531 // for frame=="CMS" - total energy of system
532 // for frame=="FIXT" - momentum of beam particle
533 // for frame=="USER" - dummy - see documentation.
534
535 Double_t lwin = win;
536 Long_t s1 = strlen(frame);
537 Long_t s2 = strlen(beam);
538 Long_t s3 = strlen(target);
539#ifndef WIN32
540 pyinit(frame,beam,target,&lwin,s1,s2,s3);
541#else
542 pyinit(frame, s1, beam , s2, target, s3, &lwin);
543#endif
544}
545
546
547int TPythia6::Pycomp(int kf) {
548 //interface with fortran routine pycomp
549 return pycomp(&kf);
550}
551
552void TPythia6::Pyedit(int medit) {
553 //interface with fortran routine pyedit
554 pyedit(&medit);
556}
557
559 //interface with fortran routine pydiff
560 pydiff();
561}
562
564 //interface with fortran routine pyevnt
565 pyevnt();
566}
567
569 //interface with fortran routine pyexec
570 pyexec();
571}
572
573void TPythia6::Pygive(const char *param) {
574 //interface with fortran routine pygive
575 Long_t lparam = strlen(param);
576 pygive(param,lparam);
577}
578
579void TPythia6::Pyhepc(int mconv) {
580 //interface with fortran routine pyhepc
581 pyhepc(&mconv);
582}
583
584void TPythia6::Pylist(int flag) {
585 //interface with fortran routine pylist
586 pylist(&flag);
587}
588
589void TPythia6::Pyname(int kf, char* name) {
590 //Note that the array name must be dimensioned in the calling program
591 //to at least name[16]
592
593 pyname(&kf,name,15);
594 // cut trailing blanks to get C string
595 name[15] = 0;
596 //for (int i=15; (i>=0) && (name[i] == ' '); i--) {
597 // name[i] = 0;
598 // }
599}
600
601double TPythia6::Pyr(int idummy) {
602 //interface with fortran routine pyr
603 return pyr(&idummy);
604}
605
606void TPythia6::Pyrget(int lun, int move) {
607 //interface with fortran routine pyrget
608 pyrget(&lun,&move);
609}
610
611void TPythia6::Pyrset(int lun, int move) {
612 //interface with fortran routine pyrset
613 pyrset(&lun,&move);
614}
615
616void TPythia6::Pystat(int flag) {
617 //interface with fortran routine pystat
618 pystat(&flag);
619}
620
621void TPythia6::Pytest(int flag) {
622 //interface with fortran routine pytest
623 pytest(&flag);
624}
625
626void TPythia6::Pytune(int itune) {
627 //interface with fortran routine pytune
628 pytune(&itune);
629}
630
631void TPythia6::Pyupda(int mupda, int lun) {
632 //interface with fortran routine pyupda
633 pyupda(&mupda,&lun);
634}
635
636double TPythia6::Pymass(int kf) {
637 //interface with fortran routine pymass
638 return pymass(&kf);
639}
640
641int TPythia6::Pychge(int kf) {
642 //interface with fortran routine pychge
643 return pychge(&kf);
644}
645
646////////////////////////////////////////////////////////////////////////////////
647/// Add one entry to the event record, i.e. either a parton or a
648/// particle.
649///
650/// - IP: normally line number for the parton/particle. There are two
651/// exceptions:
652/// - If IP = 0: line number 1 is used and PYEXEC is called.
653/// - If IP < 0: line -IP is used, with status code K(-IP,2)=2
654/// rather than 1; thus a parton system may be built
655/// up by filling all but the last parton of the
656/// system with IP < 0.
657/// - KF: parton/particle flavour code (PDG code)
658/// - PE: parton/particle energy. If PE is smaller than the mass,
659/// the parton/particle is taken to be at rest.
660/// - THETA:
661/// - PHI: polar and azimuthal angle for the momentum vector of the
662/// parton/particle.
663
665{
666 py1ent(ip, kf, pe, theta, phi);
667}
668
669
670////////////////////////////////////////////////////////////////////////////////
671/// Exemplary setup of Pythia parameters:
672/// Switches on processes 102,123,124 (Higgs generation) and switches off
673/// interactions, fragmentation, ISR, FSR...
674
676{
677 SetMSEL(0); // full user controll;
678
679 SetMSUB(102,1); // g + g -> H0
680 SetMSUB(123,1); // f + f' -> f + f' + H0
681 SetMSUB(124,1); // f + f' -> f" + f"' + H0
682
683
684 SetPMAS(6,1,175.0); // mass of TOP
685 SetPMAS(25,1,300); // mass of Higgs
686
687
688 SetCKIN(1,290.0); // range of allowed mass
689 SetCKIN(2,310.0);
690
691 SetMSTP(61, 0); // switch off ISR
692 SetMSTP(71, 0); // switch off FSR
693 SetMSTP(81, 0); // switch off multiple interactions
694 SetMSTP(111, 0); // switch off fragmentation/decay
695}
#define s1(x)
Definition: RSha256.hxx:91
int Int_t
Definition: RtypesCore.h:45
long Long_t
Definition: RtypesCore.h:54
double Double_t
Definition: RtypesCore.h:59
const char Option_t
Definition: RtypesCore.h:66
Option_t Option_t option
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t target
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t win
char name[80]
Definition: TGX11.cxx:110
#define pystat
Definition: TPythia6.cxx:92
#define pyname
Definition: TPythia6.cxx:88
#define tpythia6_close_fortran_file
Definition: TPythia6.cxx:108
#define pylist
Definition: TPythia6.cxx:86
#define pydiff
Definition: TPythia6.cxx:77
#define pyexec
Definition: TPythia6.cxx:83
#define pycomp
Definition: TPythia6.cxx:81
#define pyrget
Definition: TPythia6.cxx:90
#define pychge
Definition: TPythia6.cxx:80
#define pyhepc
Definition: TPythia6.cxx:84
#define pyr
Definition: TPythia6.cxx:89
#define type_of_call
Definition: TPythia6.cxx:110
#define pymass
Definition: TPythia6.cxx:87
ClassImp(TPythia6)
#define pyupda
Definition: TPythia6.cxx:95
#define pyinit
Definition: TPythia6.cxx:79
#define pythia6_common_address
Definition: TPythia6.cxx:106
#define pygive
Definition: TPythia6.cxx:85
#define tpythia6_open_fortran_file
Definition: TPythia6.cxx:107
#define pytest
Definition: TPythia6.cxx:93
#define pyevnt
Definition: TPythia6.cxx:78
#define pyrset
Definition: TPythia6.cxx:91
#define pytune
Definition: TPythia6.cxx:94
#define pyedit
Definition: TPythia6.cxx:82
#define py1ent
Definition: TPythia6.cxx:96
#define snprintf
Definition: civetweb.c:1540
An array of clone (identical) objects.
Definition: TClonesArray.h:29
void Clear(Option_t *option="") override
Clear the clones array.
The interface to various event generators.
Definition: TGenerator.h:144
TObjArray * fParticles
display neutrons if true
Definition: TGenerator.h:149
This class serves as a data storage for description of one particle.
Definition: TMCParticle.h:20
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:164
An array of TObjects.
Definition: TObjArray.h:31
void Clear(Option_t *option="") override
Remove all objects from the array.
Definition: TObjArray.cxx:321
void Delete(Option_t *option="") override
Remove all objects from the array AND delete all heap based objects.
Definition: TObjArray.cxx:356
friend class TClonesArray
Definition: TObject.h:228
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition: TObject.cxx:921
Description of the dynamic properties of a particle.
Definition: TParticle.h:26
Utility class to manage the TPythia6 instance.
Definition: TPythia6.h:111
~TPythia6Cleaner()
delete the TPythia6 insntance
Definition: TPythia6.cxx:191
TPythia is an interface class to F77 version of Pythia 6.2
Definition: TPythia6.h:84
void Pyname(int kf, char *name)
Definition: TPythia6.cxx:589
double Pymass(int kf)
Definition: TPythia6.cxx:636
Pyint6_t * fPyint6
Definition: TPythia6.h:102
Pydatr_t * fPydatr
Definition: TPythia6.h:94
Pyint2_t * fPyint2
Definition: TPythia6.h:98
double Pyr(int idummy)
Definition: TPythia6.cxx:601
Int_t ImportParticles(TClonesArray *particles, Option_t *option="")
Default primary creation method.
Definition: TPythia6.cxx:364
void Pylist(int flag)
Definition: TPythia6.cxx:584
static TPythia6 * Instance()
model of automatic memory cleanup suggested by Jim Kowalkovski: destructor for local static variable ...
Definition: TPythia6.cxx:287
Pymssm_t * fPymssm
Definition: TPythia6.h:106
void SetupTest()
Exemplary setup of Pythia parameters: Switches on processes 102,123,124 (Higgs generation) and switch...
Definition: TPythia6.cxx:675
int Pycomp(int kf)
Definition: TPythia6.cxx:547
virtual ~TPythia6()
Destroys the object, deletes and disposes all TMCParticles currently on list.
Definition: TPythia6.cxx:273
Pyint4_t * fPyint4
Definition: TPythia6.h:100
void Pyrset(int lun, int move)
Definition: TPythia6.cxx:611
void CloseFortranFile(int lun)
interface with fortran i/o
Definition: TPythia6.cxx:314
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.
Definition: TPythia6.cxx:438
static TPythia6 * fgInstance
Definition: TPythia6.h:87
Pybins_t * fPybins
Definition: TPythia6.h:109
void OpenFortranFile(int lun, char *name)
interface with fortran i/o
Definition: TPythia6.cxx:307
Pyint3_t * fPyint3
Definition: TPythia6.h:99
void Pytest(int flag)
Definition: TPythia6.cxx:621
Pysubs_t * fPysubs
Definition: TPythia6.h:95
void SetMSEL(int m)
Definition: TPythia6.h:210
void SetCKIN(int i, double c)
Definition: TPythia6.h:213
void Pydiff()
Definition: TPythia6.cxx:558
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.
Definition: TPythia6.cxx:664
void Pyevnt()
Definition: TPythia6.cxx:563
void Pyexec()
Definition: TPythia6.cxx:568
void SetPMAS(int ip, int i, double m)
Definition: TPythia6.h:171
int Pychge(int kf)
Definition: TPythia6.cxx:641
Pydat1_t * fPydat1
Definition: TPythia6.h:90
Pyint9_t * fPyint9
Definition: TPythia6.h:105
void Pyhepc(int mconv)
Definition: TPythia6.cxx:579
void GenerateEvent()
generate event and copy the information from /HEPEVT/ to fPrimaries
Definition: TPythia6.cxx:299
void Pyinit(char *frame, char *beam, char *target, double wint)
Definition: TPythia6.cxx:517
void Pyupda(int mupda, int lun)
Definition: TPythia6.cxx:631
Pyint1_t * fPyint1
Definition: TPythia6.h:97
void Pygive(const char *param)
Definition: TPythia6.cxx:573
void SetMSUB(int i, int m)
Definition: TPythia6.h:212
Pyjets_t * fPyjets
Definition: TPythia6.h:89
void SetMSTP(int i, int m)
Definition: TPythia6.h:224
Pyssmt_t * fPyssmt
Definition: TPythia6.h:107
Pypars_t * fPypars
Definition: TPythia6.h:96
Pyint7_t * fPyint7
Definition: TPythia6.h:103
Pyints_t * fPyints
Definition: TPythia6.h:108
TPythia6()
TPythia6 constructor: creates a TClonesArray in which it will store all particles.
Definition: TPythia6.cxx:206
void Pystat(int flag)
Definition: TPythia6.cxx:616
void Pyrget(int lun, int move)
Definition: TPythia6.cxx:606
Pydat4_t * fPydat4
Definition: TPythia6.h:93
Pydat3_t * fPydat3
Definition: TPythia6.h:92
void Pytune(int itune)
Definition: TPythia6.cxx:626
void Pyedit(int medit)
Definition: TPythia6.cxx:552
Pydat2_t * fPydat2
Definition: TPythia6.h:91
Pyint8_t * fPyint8
Definition: TPythia6.h:104
Pyint5_t * fPyint5
Definition: TPythia6.h:101
Pythia6 common block Pybins.
Pythia6 common block Pydat1.
Definition: TPythia6Calls.h:67
Pythia6 common block Pydat2.
Definition: TPythia6Calls.h:75
Pythia6 common block Pydat3.
Definition: TPythia6Calls.h:83
Pythia6 common block Pydat4.
Definition: TPythia6Calls.h:91
Pythia6 common block Pydatr.
Definition: TPythia6Calls.h:96
Pythia6 common block Pyint1.
Pythia6 common block Pyint2.
Pythia6 common block Pyint3.
Pythia6 common block Pyint4.
Pythia6 common block Pyint5.
Pythia6 common block Pyint6.
Pythia6 common block Pyint7.
Pythia6 common block Pyint8.
Pythia6 common block Pyint9.
Pythia6 common block Pyints.
Pythia6 common block Pyjets.
Definition: TPythia6Calls.h:58
int K[5][4000]
Definition: TPythia6Calls.h:61
double P[5][4000]
Definition: TPythia6Calls.h:62
double V[5][4000]
Definition: TPythia6Calls.h:63
Pythia6 common block Pymssm.
Pythia6 common block Pypars.
Pythia6 common block Pyssmt.
Pythia6 common block Pysubs.
auto * a
Definition: textangle.C:12