Elsevier Science Home
Computer Physics Communications Program Library
Full text online from Science Direct
Programs in Physics & Physical Chemistry
CPC Home

[Licence| Download | New Version Template] adtj_v2_2.tar.gz(1616 Kbytes)
Manuscript Title: A Trick to Improve the Efficiency of Generating Unweighted Bc Events from BCVEGPY
Authors: Xian-You Wang, Xing-Gang Wu
Program title: BCVEGPY2.1a
Catalogue identifier: ADTJ_v2_2
Distribution format: tar.gz
Journal reference: Comput. Phys. Commun. 183(2012)442
Programming language: FORTRAN 77/90.
Computer: Any LINUX based on PC with FORTRAN 77 or FORTRAN 90 and GNU C compiler.
Operating system: LINUX.
RAM: About 2.0 MB
Supplementary material: Files containing the Figures mentioned in the "Summary of revisions:" in this section are available.
Keywords: Event generator, Hadronic production, Bc Meson, Unweighted events.
PACS: 14.40.Nd, 12.38.Bx, 12.39.Jh.
Classification: 11.2, 11.5.

Does the new version supersede the previous version?: No

Nature of problem:
Hadronic Production Bc meson and its excited states.

Solution method:
To generate weighted and unweighted Bc events within PYTHIA environment effectively.

Reasons for new version:
More and more data are accumulated at the large hadronic collider, it should be possible to make precise studies on Bc meson properties, such as its lifetime, mass spectrum and etc.. The BCVEGPY has been adopted by several experimental groups due to its high efficiency in comparison to that of PYTHIA. However, to generate unweighted events with PYTHIA inner mechanism as programmed by the previous version is still time-consuming. And it would be helpful to improve the efficiency for generating unweighted events within PYTHIA environment. Moreover, it would be better to use a uniform and standard output format for further detector simulation.

Summary of revisions:
  1. The generator BCVEGPY [1-3] has been programmed to generate Bc events under the PYTHIA environment [4] which has been frequently adopted for theoretical and experimental studies, e.g. Refs. [5-18]. It is found that each experimental group will have its own simulation software architecture, and the users will spend a lot of time writing an interface so as to implement BCVEGPY into their own software. So it would be better to supply a standard output.

    The LHE format becomes a standard format [19], which is proposed to store process and event information from the matrix-element-based generators. The users can pass this parton-level information to the general event generators like PYTHIA and HERWIG [20] for further simulation. For such purposes, we add two common blocks in genevent.F. One common block is called as bcvegpy_pyupin and the other one is write_lhe. bcvegpy_pyupin, which is similar to the PYUPIN subroutine in PYTHIA, stores the initialization information in the HEPRUP common block.

    INTEGER MAXPUP
    PARAMETER (MAXPUP=100)
    INTEGER IDBMUP,PDFGUP,PDFSUP,IDWTUP,NPRUP,LPRUP
    DOUBLE PRECISION EBMUP,XSECUP,XERRUP,XMAXUP
    COMMON/HEPRUP/IDBMUP(2),EBMUP(2),PDFGUP(2),
    &PDFSUP(2),IDWTUP,NPRUP,XSECUP(MAXPUP),
    &XERRUP(MAXPUP),XMAXUP(MAXPUP),LPRUP(MAXPUP)


    The write lhe, which is similar to the PYUPEV subroutine in PYTHIA, stores the information of each separate event in the HEPEUP common block.

    INTEGER MAXNUP
    PARAMETER (MAXNUP=500)
    INTEGER NUP,IDPRUP,IDUP,ISTUP,MOTHUP,ICOLUP
    DOUBLE PRECISION XWGTUP,SCALUP,AQEDUP,
    &AQCDUP,PUP,VTIMUP,SPINUP
    COMMON/HEPEUP/NUP,IDPRUP,XWGTUP,SCALUP,AQEDUP,
    &AQCDUP,IDUP(MAXNUP),ISTUP(MAXNUP),
    &MOTHUP(2,MAXNUP),ICOLUP(2,MAXNUP),PUP(5,MAXNUP),
    &VTIMUP(MAXNUP),SPINUP(MAXNUP)


    The above information can be separately exported to two files 'bcvegpy.init' and 'bcvegpy.evnt'. Then with the help of the PYTHIA subroutine PYLHEF, we can combine these two files into a single LHE file 'bcvegpy.lhe'.

  2. As for previous version of BCVEGPY [1-3], its main concern is to improve theoretical estimations, i.e. to obtain a precise result as fast as possible. For the purpose, the VEGAS [21] running together with IDWTUP=3 is usually appreciated. Firstly, by running VEGAS, one can obtain a sampling importance function, and then the phase-space points are generated according to the relative importance of their corresponding differential cross-sections. This sampling importance function is useful, since the integrand for the phase space integration can be regularized for obtaining a high precision total/differential cross section [21]. Secondly, by setting IDWTUP=3, all parton-level events when input to PYTHIA shall always be accepted, i.e. almost all the calculated points are effective ones and shall be evolved as final events. As a combination of these two choices, one can generate events within the so-called importance sampling approach, i.e. the parton-level events have been effectively input into PYTHIA with properly weighted phase space. This is one of the reasons why BCVEGPY runs so fast - Nevertheless, the dominant reason for its quick running is due to the use of the improved helicity amplitude approach to deal with the hard scattering amplitude as described in detail in Ref.[1].

    Experimentally, it is the unweighted inputs other than the weighted inputs that are usually needed. By default BCVEGPY generates unweighted events following the same scheme of PYTHIA. For the purpose, one has to set the PYTHIA parameter IDWTUP=1, then all events in a run are treated on an equal footing. And the parton-level events are uniformly generated within the whole phase space, but with a weight (XWGTUP) when input to PYTHIA, and then these events are accepted or rejected with probability XWGTUP/XMAXUP (XMAXUP is the maximum weight of the process). As most of the calculated parton-level events are rejected by this criteria, such a naive scheme is usually time-consuming. For example, by setting IDWTUP=1, it takes about 20 hours on a 1.8 GHz Intel P4-processor machine to generate 1000 Bc events. It is too slow if one wants to simulate large amount of events.

    So, we present a new scheme to improve the efficiency of generating unweighted events within the PYTHIA environment. For the purpose, we first unweight the events by using the standard hit-and-miss technique [22]. Then, we set IDWTUP=1, but we replace XMAXUP to be a reference weight that can be generated by earlier exploratory run - The function of the reference weight is similar to that of XMAXUP, and for convenience, we still use the label XMAXUP to store its value. Each parton-level event will result in a ratio between the weight XWGTUP and the reference weight. When such ratio is smaller than one, the event shall be retained or rejected based on whether the ratio is greater or less than the return value of random number generating function PYR(0).

    When the ratio is larger than one, its integral part stands for the basic number the same events to be generated. And the basic number shall be increased by one or unchanged based on whether its decimal part is greater or less than a random number PYR(0). It is found that a larger reference weight means more events to be rejected and less efficiency. So, to set a proper reference weight is a tricky problem, which requires exploratory running under one's own experimental cuts and should have negligible derivation from theoretical estimations.

    For example, one may observe that for ATLAS transverse momentum cut PTcut = 4 GeV and the rapidity cut ycut = 2.5, only few events' weight are larger than the value of 106 pb. So we can set this valve as the reference weight, which is reasonable for the LHC Bc production simulation.

    The code for the newly suggested unweighted scheme is put in the main program 'bcvegpy.F'. As a cross check, we present the weighted and unweighted Bc transverse momentum PT-distribution and pseudo-rapidity η-distribution in Fig.(1), which are represented by solid line and dotted lines respectively. The unweighted distributions are obtained by setting IDWTUP=1 and using the new strategy described above, while the weighted distributions are obtained by setting IDWTUP=3. It can be found that the weighted and unweighted distributions coincide with each other. Since the new unweighted scheme is time-saving in comparison with that of the previous one, it can be adopted for generating large amount of events, which may suit the needs of the newly accumulating data at LHC.

    Moreover, to compare and validate the result of BCVEGPY, we also use PYTHIA's inner mechanism to generate Bc meson at the very beginning. For such purposes, we set MSEL=5 to generate bbbar first, and then add one filter (PDGID=541) that searches and stores every event that shall result in at least one Bc meson. Next, we use the external decay generator EVTGEN [10], which can be run under the PYTHIA environment, to simulate the Bc decay channel BcJ/ψ + π. The remaining parameters for PYTHIA are taken to be their default values. Moreover, in doing the calculation, we set the collision energy of LHC to be the present value of 7 TeV. The comparison is presented in Fig.(2), which shows that the normalized distributions for PYTHIA and BCVEGPY agree with each other well. Such an observation agrees with the conclusion drawn by Ref.[12].

Restrictions:
Hadronic production of (cbbar)-quarkonium via the gluon-gluon fusion mechanism are given by the 'complete calculation approach'. The simulation of Bc events is done within the PYTHIA environment.

Running time:
Running time is machine and user-parameters dependent.
  1. To generate 106 weighted S-wave (cbbar)-quarkonium events (IDWTUP=3), will take about 40 minutes on a 1.8 GHz Intel P4-processor machine.
  2. To generate unweighted S-wave (cbbar)-quarkonium events with PYTHIA inner structure (IDWTUP=1), will take about 20 hours on a 1.8 GHz Intel P4-processor machine to generate 1000 events.
  3. To generate 106 weighted S-wave (cbbar)-quarkonium events with the present trick (IDWTUP=3), will take 17 hours on a 3.16 GHz Intel E8500 processor machine.
Moreover, it can be found that the running time for the P-wave (cbbar)-quarkonium production is about two times longer than the case of S-wave production under the same conditions.

References:
[1] C.-H. Chang, C. Driouich, P. Eerola and X.-G.Wu, Comput.Phys.Commun. 159 (2004) 192;
[2] C.-H. Chang, J.-X. Wang and X.-G. Wu, Comput.Phys.Commun. 174 (2006) 241;
[3] C.-H. Chang, J.-X. Wang and X.-G. Wu, Comput.Phys.Commun. 175 (2006) 624.
[4] T. Sjostrand, S. Mrenna and P. Skands, JHEP 0605, 026(2006).
[5] C.H. Chang and X.G. Wu, Eur.Phys.J. C38, 267(2004).
[6] C.H. Chang, J.X. Wang and X.G. Wu, Phys.Rev. D70, 114019(2004).
[7] N. Brambilla, et al., Quarkonium Working Group Collaboration, hep-ph/0412158.
[8] C.H. Chang, C.F. Qiao, J.X. Wang and X.G. Wu, Phys.Rev. D71, 074012(2005).
[9] C.H. Chang, C.F. Qiao, J.X. Wang and X.G. Wu, Phys.Rev. D72, 114009(2005).
[10] J.W. Zhang, et al., Phys.Rev. D79, 114012(2009).
[11] N. Brambilla, et al., Quarkonium Working Group Collaboration, Eur.Phys.J. C71, 1534(2011).
[12] S.H. Zhang, A.A. Belkov, S.Shulga and G.M. Chen, Chin.Phys.Lett. 21, 2380(2004).
[13] P. Eerola, AIP Conf. Proc. 722, 242(2004).
[14] A. Abulencia, et al., CDF Collaboration, Phys.Rev.Lett. 96, 082002(2006).
[15] A. Abulencia, et al., CDF Collaboration, Phys.Rev.Lett. 97, 012002(2006).
[16] W.X. Meng, Chin.Phys. C 32, 83(2008).
[17] Y.N. Gao, et al., Chin.Phys.Lett. 27, 061302(2010).
[18] J. He, for the LHCb Collaboration, arXiv: 1001.5370 [hep-ex].
[19] J. Alwall, et al., Comput.Phys.Commun. 176 (2007) 300.
[20] G. Corcella, et al., hep-ph/0210213; M. Bahr, et al.,Eur.Phys.J. C58, 639(2008).
[21] G.P. Lepage, J. Comp. Phys 27, 192 (1978).
[22] M. Dobbs and M. Lefebvre, Phys.Rev. D63 053011(2001).
[23] A. Ryd, et al., EvtGen: A Monte Carlo Generator for B-Physics, EVTGEN-V00-11-07 (2005