THERMUS—A thermal model package for ROOT

THERMUS is a package of C++ classes and functions allowing statistical-thermal model analyses of particle production in relativistic heavy-ion collisions to be performed within the ROOT framework of analysis. Calculations are possible within three statistical ensembles; a grand-canonical treatment of the conserved charges B, S and Q, a fully canonical treatment of the conserved charges, and a mixed-canonical ensemble combining a canonical treatment of strangeness with a grand-canonical treatment of baryon number and electric charge. THERMUS allows for the assignment of decay chains and detector efficiencies specific to each particle yield, which enables sensible fitting of model parameters to experimental data.

Program summary

Program title: THERMUS, version 2.1Catalogue identifier: AEBW_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEBW_v1_0.htmlProgram obtainable from: CPC Program Library, Queen's University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 17 152No. of bytes in distributed program, including test data, etc.: 93 581Distribution format: tar.gzProgramming language: C++Computer: PC, Pentium 4, 1 GB RAM (not hardware dependent)Operating system: Linux: FEDORA, RedHat, etc.Classification: 17.7External routines: Numerical Recipes in C [1], ROOT [2]Nature of problem: Statistical-thermal model analyses of heavy-ion collision data require the calculation of both primordial particle densities and contributions from resonance decay. A set of thermal parameters (the number depending on the particular model imposed) and a set of thermalized particles, with their decays specified, is required as input to these models. The output is then a complete set of primordial thermal quantities for each particle, together with the contributions to the final particle yields from resonance decay. In many applications of statistical-thermal models it is required to fit experimental particle multiplicities or particle ratios. In such analyses, the input is a set of experimental yields and ratios, a set of particles comprising the assumed hadron resonance gas formed in the collision and the constraints to be placed on the system. The thermal model parameters consistent with the specified constraints leading to the best-fit to the experimental data are then output.Solution method: THERMUS is a package designed for incorporation into the ROOT [2] framework, used extensively by the heavy-ion community. As such, it utilizes a great deal of ROOT's functionality in its operation. ROOT features used in THERMUS include its containers, the wrapper TMinuit implementing the MINUIT fitting package, and the TMath class of mathematical functions and routines. Arguably the most useful feature is the utilization of CINT as the control language, which allows interactive access to the THERMUS objects. Three distinct statistical ensembles are included in THERMUS, while additional options to include quantum statistics, resonance width and excluded volume corrections are also available. THERMUS provides a default particle list including all mesons (up to the (2045)) and baryons (up to the Ω⁻) listed in the July 2002 Particle Physics Booklet [3]. For each typically unstable particle in this list, THERMUS includes a text-file listing its decays. With thermal parameters specified, THERMUS calculates primordial thermal densities either by performing numerical integrations or else, in the case of the Boltzmann approximation without resonance width in the grand-canonical ensemble, by evaluating Bessel functions. Particle decay chains are then used to evaluate experimental observables (i.e. particle yields following resonance decay). Additional detector efficiency factors allow fine-tuning of the model predictions to a specific detector arrangement. When parameters are required to be constrained, use is made of the ‘Numerical Recipes in C’ [1] function which applies the Broyden globally convergent secant method of solving nonlinear systems of equations. Since the NRC software is not freely-available, it has to be purchased by the user. THERMUS provides the means of imposing a large number of constraints on the chosen model (amongst others, THERMUS can fix the baryon-to-charge ratio of the system, the strangeness density of the system and the primordial energy per hadron). Fits to experimental data are accomplished in THERMUS by using the ROOT TMinuit class. In its default operation, the standard χ² function is minimized, yielding the set of best-fit thermal parameters. THERMUS allows the assignment of separate decay chains to each experimental input. In this way, the model is able to match the specific feed-down corrections of a particular data set.Running time: Depending on the analysis required, run-times vary from seconds (for the evaluation of particle multiplicities given a set of parameters) to several minutes (for fits to experimental data subject to constraints).References:

[1]

W.H. Press, S.A. Teukolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in C: The Art of Scientific Computing, Cambridge University Press, Cambridge, 2002.

[2]

R. Brun, F. Rademakers, Nucl. Inst. Meth. Phys. Res. A 389 (1997) 81. See also http://root.cern.ch/.

[3]

K. Hagiwara et al., Phys. Rev. D 66 (2002) 010001.

     

Heavy ion event generator HYDJET++ (HYDrodynamics plus JETs)

HYDJET++ is a Monte Carlo event generator for simulation of relativistic heavy ion AA collisions considered as a superposition of the soft, hydro-type state and the hard state resulting from multi-parton fragmentation. This model is the development and continuation of HYDJET event generator (Lokhtin and Snigirev, EPJC 45 (2006) 211). The main program is written in the object-oriented C++ language under the ROOT environment. The hard part of HYDJET++ is identical to the hard part of Fortran-written HYDJET and it is included in the generator structure as a separate directory. The soft part of HYDJET++ event is the “thermal” hadronic state generated on the chemical and thermal freeze-out hypersurfaces obtained from the parameterization of relativistic hydrodynamics with preset freeze-out conditions. It includes the longitudinal, radial and elliptic flow effects and the decays of hadronic resonances. The corresponding fast Monte Carlo simulation procedure, C++ code FAST MC (Amelin et al., PRC 74 (2006) 064901; PRC 77 (2008) 014903) is adapted to HYDJET++. It is designed for studying the multi-particle production in a wide energy range of heavy ion experimental facilities: from FAIR and NICA to RHIC and LHC.

Program summary

Program title: HYDJET++, version 2Catalogue identifier: AECR_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AECR_v1_0.htmlProgram obtainable from: CPC Program Library, Queen's University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 100 387No. of bytes in distributed program, including test data, etc.: 797 019Distribution format: tar.gzProgramming language: C++ (however there is a Fortran-written part which is included in the generator structure as a separate directory)Computer: Hardware independent (both C++ and Fortran compilers and ROOT environment [1] (http://root.cern.ch/) should be installed)Operating system: Linux (Scientific Linux, Red Hat Enterprise, FEDORA, etc.)RAM: 50 MBytes (determined by ROOT requirements)Classification: 11.2External routines: ROOT [1] (http://root.cern.ch/)Nature of problem: The experimental and phenomenological study of multi-particle production in relativistic heavy ion collisions is expected to provide valuable information on the dynamical behavior of strongly-interacting matter in the form of quark-gluon plasma (QGP) [2-4], as predicted by lattice Quantum Chromodynamics (QCD) calculations. Ongoing and future experimental studies in a wide range of heavy ion beam energies require the development of new Monte Carlo (MC) event generators and improvement of existing ones. Especially for experiments at the CERN Large Hadron Collider (LHC), implying very high parton and hadron multiplicities, one needs fast (but realistic) MC tools for heavy ion event simulations [5-7]. The main advantage of MC technique for the simulation of high-multiplicity hadroproduction is that it allows a visual comparison of theory and data, including if necessary the detailed detector acceptances, responses and resolutions. The realistic MC event generator has to include maximum possible number of observable physical effects, which are important to determine the event topology: from the bulk properties of soft hadroproduction (domain of low transverse momenta pT?1 GeV/c) such as collective flows, to hard multi-parton production in hot and dense QCD-matter, which reveals itself in the spectra of high-pT particles and hadronic jets. Moreover, the role of hard and semi-hard particle production at LHC can be significant even for the bulk properties of created matter, and hard probes of QGP became clearly observable in various new channels [8-11]. In the majority of the available MC heavy ion event generators, the simultaneous treatment of collective flow effects for soft hadroproduction and hard multi-parton in-medium production (medium-induced partonic rescattering and energy loss, so-called “jet quenching”) is lacking. Thus, in order to analyze existing data on low and high-pT hadron production, test the sensitivity of physical observables at the upcoming LHC experiments (and other future heavy ion facilities) to the QGP formation, and study the experimental capabilities of constructed detectors, the development of adequate and fast MC models for simultaneous collective flow and jet quenching simulations is necessary. HYDJET++ event generator includes detailed treatment of soft hadroproduction as well as hard multi-parton production, and takes into account known medium effects.Solution method: A heavy ion event in HYDJET++ is a superposition of the soft, hydro-type state and the hard state resulting from multi-parton fragmentation. Both states are treated independently. HYDJET++ is the development and continuation of HYDJET MC model [12]. The main program is written in the object-oriented C++ language under the ROOT environment [1]. The hard part of HYDJET++ is identical to the hard part of Fortran-written HYDJET [13] (version 1.5) and is included in the generator structure as a separate directory. The routine for generation of single hard NN collision, generator PYQUEN [12,14], modifies the “standard” jet event obtained with the generator PYTHIA 6.4 [15]. The event-by-event simulation procedure in PYQUEN includes

1.

generation of initial parton spectra with PYTHIA and production vertexes at given impact parameter;

2.

rescattering-by-rescattering simulation of the parton path in a dense zone and its radiative and collisional energy loss;

3.

final hadronization according to the Lund string model for hard partons and in-medium emitted gluons.

Then the PYQUEN multi-jets generated according to the binomial distribution are included in the hard part of the event. The mean number of jets produced in an AA event is the product of the number of binary NN subcollisions at a given impact parameter and the integral cross section of the hard process in NN collisions with the minimum transverse momentum transfer . In order to take into account the effect of nuclear shadowing on parton distribution functions, the impact parameter dependent parameterization obtained in the framework of Glauber-Gribov theory [16] is used. The soft part of HYDJET++ event is the “thermal” hadronic state generated on the chemical and thermal freeze-out hypersurfaces obtained from the parameterization of relativistic hydrodynamics with preset freeze-out conditions (the adapted C++ code FAST MC [17,18]). Hadron multiplicities are calculated using the effective thermal volume approximation and Poisson multiplicity distribution around its mean value, which is supposed to be proportional to the number of participating nucleons at a given impact parameter of AA collision. The fast soft hadron simulation procedure includes

1.

generation of the 4-momentum of a hadron in the rest frame of a liquid element in accordance with the equilibrium distribution function;

2.

generation of the spatial position of a liquid element and its local 4-velocity in accordance with phase space and the character of motion of the fluid;

3.

the standard von Neumann rejection/acceptance procedure to account for the difference between the true and generated probabilities;

4.

boost of the hadron 4-momentum in the center mass frame of the event;

5.

the two- and three-body decays of resonances with branching ratios taken from the SHARE particle decay table [19].

The high generation speed in HYDJET++ is achieved due to almost 100% generation efficiency of the “soft” part because of the nearly uniform residual invariant weights which appear in the freeze-out momentum and coordinate simulation. Although HYDJET++ is optimized for very high energies of RHIC and LHC colliders (c.m.s. energies of heavy ion beams and 5500 GeV per nucleon pair, respectively), in practice it can also be used for studying the particle production in a wider energy range down to per nucleon pair at other heavy ion experimental facilities. As one moves from very high to moderately high energies, the contribution of the hard part of the event becomes smaller, while the soft part turns into just a multi-parameter fit to the data.Restrictions: HYDJET++ is only applicable for symmetric AA collisions of heavy (A?40) ions at high energies (c.m.s. energy per nucleon pair). The results obtained for very peripheral collisions (with the impact parameter of the order of two nucleus radii, b∼2RA) and very forward rapidities may be not adequate.Additional comments: Accessibility http://cern.ch/lokhtin/hydjet++Running time: The generation of 100 central (0-5%) Au+Au events at (Pb+Pb events at ) with default input parameters takes about 7 (85) minutes on a PC 64 bit Intel Core Duo CPU @ 3 GHz with 8 GB of RAM memory under Red Hat Enterprise.References:[1] I.P. Lokhtin, A.M. Snigirev, Eur. Phys. J. C 46 (2006) 211.[2] N.S. Amelin, R. Lednicky, T.A. Pocheptsov, I.P. Lokhtin, L.V. Malinina, A.M. Snigirev, Iu.A. Karpenko, Yu.M. Sinyukov, Phys. Rev. C 74 (2006) 064901.[3] N.S. Amelin, I. Arsene, L. Bravina, Iu.A. Karpenko, R. Lednicky, I.P. Lokhtin, L.V. Malinina, A.M. Snigirev, Yu.M. Sinyukov, Phys. Rev. C 77 (2008) 014903.     

MC-TESTER: a universal tool for comparisons of Monte Carlo predictions for particle decays in high energy physics

Theoretical predictions in high energy physics are routinely provided in the form of Monte Carlo generators. Comparisons of predictions from different programs and/or different initialization set-ups are often necessary. MC-TESTER can be used for such tests of decays of intermediate states (particles or resonances) in a semi-automated way. Our test consists of two steps. Different Monte Carlo programs are run; events with decays of a chosen particle are searched, decay trees are analyzed and appropriate information is stored. Then, at the analysis step, a list of all found decay modes is defined and branching ratios are calculated for both runs. Histograms of all scalar Lorentz-invariant masses constructed from the decay products are plotted and compared for each decay mode found in both runs. For each plot a measure of the difference of the distributions is calculated and its maximal value over all histograms for each decay channel is printed in a summary table. As an example of MC-TESTER application, we include a test with the τ lepton decay Monte Carlo generators, TAUOLA and PYTHIA. The HEPEVT (or LUJETS) common block is used as exclusive source of information on the generated events.

Program summary

Title of the program:MC-TESTER, version 1.1Catalogue identifier: ADSMProgram summary URL:http://cpc.cs.qub.ac.uk/summaries/ADSMProgram obtainable from: CPC Program Library, Queen's University of Belfast, N. IrelandComputer: PC, two Intel Xeon 2.0 GHz processors, 512MB RAMOperating system: Linux Red Hat 6.1, 7.2, and also 8.0Programming language used:C++, FORTRAN77: gcc 2.96 or 2.95.2 (also 3.2) compiler suite with g++ and g77Size of the package: 7.3 MB directory including example programs (2 MB compressed distribution archive), without ROOT libraries (additional 43 MB).No. of bytes in distributed program, including test data, etc.: 2 024 425Distribution format: tar gzip fileAdditional disk space required: Depends on the analyzed particle: 40 MB in the case of τ lepton decays (30 decay channels, 594 histograms, 82-pages booklet).Keywords: particle physics, decay simulation, Monte Carlo methods, invariant mass distributions, programs comparisonNature of the physical problem: The decays of individual particles are well defined modules of a typical Monte Carlo program chain in high energy physics. A fast, semi-automatic way of comparing results from different programs is often desirable, for the development of new programs, to check correctness of the installations or for discussion of uncertainties.Method of solution: A typical HEP Monte Carlo program stores the generated events in the event records such as HEPEVT or PYJETS. MC-TESTER scans, event by event, the contents of the record and searches for the decays of the particle under study. The list of the found decay modes is successively incremented and histograms of all invariant masses which can be calculated from the momenta of the particle decay products are defined and filled. The outputs from the two runs of distinct programs can be later compared. A booklet of comparisons is created: for every decay channel, all histograms present in the two outputs are plotted and parameter quantifying shape difference is calculated. Its maximum over every decay channel is printed in the summary table.Restrictions on the complexity of the problem: For a list of limitations see Section 6.Typical running time: Varies substantially with the analyzed decay particle. On a PC/Linux with 2.0 GHz processors MC-TESTER increases the run time of the τ-lepton Monte Carlo program TAUOLA by 4.0 seconds for every 100000 analyzed events (generation itself takes 26 seconds). The analysis step takes 13 seconds; processing takes additionally 10 seconds. Generation step runs may be executed simultaneously on multi-processor machines.Accessibility: web page: http://cern.ch/Piotr.Golonka/MC/MC-TESTER e-mails: Piotr.Golonka@CERN.CH, T.Pierzchala@friend.phys.us.edu.pl, Zbigniew.Was@CERN.CH.     

Decay of super-heavy particles: user guide of the SHdecay program

I give here a detailed user guide for the C++ program SHdecay, which has been developed for computing the final spectra of stable particles (protons, photons, LSPs, electrons, neutrinos of the three species and their antiparticles) arising from the decay of a super-heavy X particle. It allows to compute in great detail the complete decay cascade for any given decay mode into particles of the Minimal Supersymmetric Standard Model (MSSM). In particular, it takes into account all interactions of the MSSM during the perturbative cascade (including not only QCD, but also the electroweak and 3rd generation Yukawa interactions), and includes a detailed treatment of the SUSY decay cascade (for a given set of parameters) and of the non-perturbative hadronization process. All these features allow us to ensure energy conservation over the whole cascade up to a numerical accuracy of a few per mille. Yet, this program also allows to restrict the computation to QCD or SUSY-QCD frameworks. I detail the input and output files, describe the role of each part of the program, and include some advice for using it best.

Program summary

Title of program: SHdecayCatalogue identifier:ADSLProgram summary URL:http://cpc.cs.qub.ac.uk/summaries/ADSLProgram obtainable from: CPC Program Library, Queen's University of Belfast, N. IrelandComputer and operating system: Program tested on PC running Linux KDE and Suse 8.1Programming language used: C with STL C++ library and using the standard gnu g++ compilerNo. lines in distributed program: 14 955No. of bytes in distributed program, including test data, etc.: 624 487Distribution format: tar gzip fileKeywords: Super-heavy particles, fragmentation functions, DGLAP equations, supersymmetry, MSSM, UHECRNature of physical problem: Obtaining the energy spectra of the final stable decay products (protons, photons, electrons, the three species of neutrinos and the LSPs) of a decaying super-heavy X particle, within the framework of the Minimal Supersymmetric Standard Model (MSSM). It can be done numerically by solving the full set of DGLAP equations in the MSSM for the perturbative evolution of the fragmentation functions Dp2p1(x,Q) of any particle p1 into any other p2 (x is the energy fraction carried by the particle p2 and Q its virtuality), and by treating properly the different decay cascades of all unstable particles and the final hadronization of quarks and gluons. In order to obtain proper results at very low values of x (up to x∼10−13), NLO color coherence effects have been included by using the Modified Leading Log Approximation (MLLA).Method of solution: the DGLAP equations are solved by a four order Runge-Kutta method with a fixed step.Typical running time: Around 35 hours for the first run, but the most time consuming sub-programs can be run only once for most applications.     

DRAGON: Monte Carlo generator of particle production from a fragmented fireball in ultrarelativistic nuclear collisions

A Monte Carlo generator of the final state of hadrons emitted from an ultrarelativistic nuclear collision is introduced. An important feature of the generator is a possible fragmentation of the fireball and emission of the hadrons from fragments. Phase space distribution of the fragments is based on the blast wave model extended to azimuthally non-symmetric fireballs. Parameters of the model can be tuned and this allows to generate final states from various kinds of fireballs. A facultative output in the OSCAR1999A format allows for a comprehensive analysis of phase-space distributions and/or use as an input for an afterburner.

Program summary

Program title: DRAGONCatalogue identifier: AEDK_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEDK_v1_0.htmlProgram obtainable from: CPC Program Library, Queen's University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 6383No. of bytes in distributed program, including test data, etc.: 32 756Distribution format: tar.gzProgramming language: C++Computer: PC Pentium 4, though no particular tuning for this machine was performedOperating system: Linux; the program has been successfully run on Gentoo Linux 2.6, RedHat Linux 9, Debian Linux 4.0, all with g++ compiler. It also ran successfully on MS Windows under Microsoft Visual C++ 2008 Express Edition as well as under cygwin/g++RAM: 100 MbytesSupplementary material: Sample output files from the test run, provided in the distribution, are available.Classification: 11.2Nature of problem: Deconfined matter produced in ultrarelativistic nuclear collisions expands and cools down and eventually returns into the confined phase. If the expansion is fast, the fireball could fragment either due to spinodal decomposition or due to suddenly arising bulk viscous force. Particle abundances are reasonably well described with just a few parameters within the statistical approach. Momentum spectra integrated over many events can be interpreted as produced from an expanding and locally thermalised fireball. The present Monte Carlo model unifies these approaches: fireball decays into fragments of some characteristic size. The fragments recede from each other as given by the pre-existing expansion of the fireball. They subsequently emit stable and unstable hadrons with momenta generated according to thermal distribution. Resonances then decay and their daughters acquire momenta as dictated by decay kinematics.Solution method: The Monte Carlo generator repeats a loop in which it generates individual events. First, sizes of fragments are generated. Then the fragments are placed within the decaying fireball and their velocities are determined from the one-to-one correspondence between the position and the expansion velocity in the blast wave model. Since hadrons may be emitted from fragments as well as from the remaining bulk fireball, first those from the bulk are generated according to the blast wave model. Then, hadron production from the fragments is treated. Each hadron is generated in the rest frame of the fragment and then boosted to the global frame. Finally, after all directly produced hadrons are generated, resonance decay channels are chosen and the momenta and positions of final state hadrons are determined.Running time: Generation of 100 events can take anything between 2 hours to a couple of days. This depends mainly on the size and density of fragments. Simulations with small fragments may be very slow. At the beginning of a run there is a period of up to 1 hour in which the program calculates thermal weights due to statistical model. This period is long if many species are included in the simulation.     

The tauola-photos-F environment for the TAUOLA and PHOTOS packages, release II

We present the system for maintaining the versions of two packages: the TAUOLA of τ-lepton decay and PHOTOS for radiative corrections in decays. The following features can be chosen in an automatic or semi-automatic way: (1) format of the common block HEPEVT; (2) version of the physics input (for TAUOLA): as published, as initialized by the CLEO collaboration, as initialized by the ALEPH collaboration (it is suggested to use this version only with the help of the collaboration advice), new optional parametrization of matrix elements in 4π decay channels; (3) type of application: stand-alone, universal interface based on the information stored in the HEPEVT common block including longitudinal spin effects in the elementary Z/γ^∗→τ⁺τ⁻ process, extended version of the standard universal interface including full spin effects in the H/A→τ⁺τ⁻ decay, interface for KKMC Monte Carlo, (4) random number generators; (5) compiler options. The last section of the paper contains documentation of the programs updates introduced over the last two years.

Program summary

Title of program:tauola-photos-F, release IICatalogue identifier:ADXO_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/ADXO_v1_0Programs obtainable from: CPC Program Library, Queen's University of Belfast, N. IrelandComputer: PC running GNU/Linux operating systemProgramming languages and tools used:CPP: standard C-language preprocessor, GNU Make builder tool, also FORTRAN compilerNo. of lines in distributed program, including test data, etc.: 194 118No. of bytes in distributed program, including test data, etc.:2 481 234Distribution format: tar.gzCatalogue identifier:ADXO_v2_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/ADXO_v2_0No. of lines in distributed program, including test data, etc.:308 235No. of bytes in distributed program, including test data, etc.:2 988 363Distribution format:tar.gzDoes the new version supersede the previous version:YesNature of the physical problem: The code of Monte Carlo generators often has to be tuned to the needs of large HEP Collaborations and experiments. Usually, these modifications do not introduce important changes in the algorithm, but rather modify the initialization and form of the hadronic current in τ decays. The format of the event record (HEPEVT common block) used to exchange information between building blocks of Monte Carlo systems often needs modification. Thus, there is a need to maintain various, slightly modified versions of the same code. The package presented here allows the production of ready-to-compile versions of TAUOLA [S. Jadach, Z. Wa?s, R. Decker, J.H. Kühn, Comput. Phys. Comm. 76 (1993) 361; A.E. Bondar, et al., Comput. Phys. Comm. 146 (2002) 139] and PHOTOS [E. Barberio, Z. Wa?s, Comput. Phys. Comm. 79 (1994) 291] Monte Carlo generators with appropriate demonstration programs. The new algorithm, universal interface of TAUOLA to work with the HEPEVT common block, is also documented here. Finally, minor technical improvements of TAUOLA and PHOTOS are also listed.Method of solution: The standard UNIX tool: the C-language preprocessor is used to produce a ready-to-distribute version of TAUOLA and PHOTOS code. The final FORTRAN code is produced from the library of ‘pre-code’ that is included in the package.Reasons for new version: The functionality of the version of TAUOLA and PHOTOS changed over the last two years. The changes, and their reasons, are documented in Section 9, and our new papers cited in this section.Additional comments: The updated version includes new features described in Section 9 of the paper. PHOTOS and TAUOLA were first submitted to the library as separate programs. Summary details of these previous programs are obtainable from the CPC Program Library.Typical running time: Depends on the speed of the computer used and the demonstration program chosen. Typically a few seconds.     

2HDMC - two-Higgs-doublet model calculator

We describe the public C++ code 2HDMC which can be used to perform calculations in a general, CP-conserving, two-Higgs-doublet model (2HDM). The program features simple conversion between different parametrizations of the 2HDM potential, a flexible Yukawa sector specification with choices of different Z₂-symmetries or more general couplings, a decay library including all two-body - and some three-body - decay modes for the Higgs bosons, and the possibility to calculate observables of interest for constraining the 2HDM parameter space, as well as theoretical constraints from positivity and unitarity. The latest version of the 2HDMC code and full documentation is available from: http://www.isv.uu.se/thep/MC/2HDMC.

Program summary

Program title:2HDMCCatalogue identifier: AEFI_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEFI_v1_0.htmlProgram obtainable from: CPC Program Library, Queen's University, Belfast, N. IrelandLicensing provisions: GNU GPLNo. of lines in distributed program, including test data, etc.: 12 032No. of bytes in distributed program, including test data, etc.: 90 699Distribution format: tar.gzProgramming language: C++Computer: Any computer running LinuxOperating system: LinuxRAM: 5 MbClassification: 11.1External routines: GNU Scientific Library (http://www.gnu.org/software/gsl/)Nature of problem: Determining properties of the potential, calculation of mass spectrum, couplings, decay widths, oblique parameters, muon g−2, and collider constraints in a general two-Higgs-doublet model.Solution method: From arbitrary potential and Yukawa sector, tree-level relations are used to determine Higgs masses and couplings. Decay widths are calculated at leading order, including FCNC decays when applicable. Decays to off-shell vector bosons are obtained by numerical integration. Observables are computed (analytically or numerically) as function of the input parameters.Restrictions: CP-violation is not treated.Running time: Less than 0.1 s on a standard PC     

micrOMEGAs: Version 1.3

We present the latest version of micrOMEGAs, a code that calculates the relic density of the lightest supersymmetric particle (LSP) in the minimal supersymmetric standard model (MSSM). All tree-level processes for the annihilation of the LSP are included as well as all possible coannihilation processes with neutralinos, charginos, sleptons, squarks and gluinos. The cross-sections extracted from CalcHEP are calculated exactly using loop-corrected masses and mixings as specified in the SUSY Les Houches Accord. Relativistic formulae for the thermal average are used and care is taken to handle poles and thresholds by adopting specific integration routines. The input parameters can be either the soft SUSY parameters in a general MSSM or the parameters of a SUGRA model specified at the GUT scale. In the latter case, a link with Suspect, SOFTSUSY, Spheno and Isajet allows one to calculate the supersymmetric spectrum, Higgs masses, as well as mixing matrices. Higher-order corrections to Higgs couplings to quark pairs including QCD as well as some SUSY corrections (Δmb) are implemented. Routines calculating μ(g−2), b→sγ and Bs→μ⁺μ⁻ are also included. In particular the b→sγ routine includes an improved NLO for the SM and the charged Higgs while the SUSY large tanβ effects beyond leading-order are included. This new version also provides cross-sections for any 2→2 process as well as partial decay widths for two-body final states in the MSSM allowing for easy simulation at colliders.

Program summary

Program title:micrOMEGAs1.3Catalogue identifier:ADQR_v1_3Program summary URL:http://cpc.cs.qub.ac.uk/summaries/ADQR_v1_3Program obtainable from: CPC Program Library, Queen's University of Belfast, N. IrelandLicensing provisions:noneComputer:PC, Alpha, Silicon graphics, SunProgramming language:C and FortranOperating system:UNIX (Linux, OSF1, IRIX64, SunOS)RAM:20 MB depending on the number of processes requiredNo of lines in distributed program, including test data, etc.:78 314No. of bytes in distributed program, including test data, etc.:703 112Distribution format:tar.gzNumber of processors used:1External routines/libraries:Library of Fortran functions, for example, -lg2c (platform dependent)Catalogue identifier of previous version:ADQRJournal reference of previous version:Comput. Phys. Comm. 149 (2002) 103Does the new version supersede the previous version?:yesNature of problem:Calculation of the relic density of the lightest supersymmetric particle in the MSSM.Solution method:In numerically solving the evolution equation for the density of dark matter, relativistic formulae for the thermal average are used. All tree-level processes for annihilation and coannihilation of SUSY particles are included. The cross-sections for all processes are calculated exactly with CalcHEP. Higher-order corrections to Higgs masses and Higgs couplings to quark pairs including QCD as well as some SUSY corrections are implemented. The input parameters can be either the soft SUSY parameters in a general MSSM or the parameters of a SUGRA model specified at the GUT scale. In the latter case, a link with Suspect, SOFTSUSY, Spheno and Isajet allows to calculate the supersymmetric spectrum, Higgs masses, as well as mixing matrices.Reasons for the new version:This new version contains a more accurate calculation of the relic density of dark matter as well as many new features both for interface with codes that calculate the supersymmetric spectrum as well as for computation of cross-sections and decays relevant for collider physics.Summary of revisions:

•

Interface with the main codes to calculate the supersymmetric spectrum: Suspect, Isajet, Spheno and SOFTSUSY in models defined at some high scale.

•

Includes loop corrected sparticle masses and mixing matrices.

•

Includes loop-corrected Higgs masses and widths. QCD corrections to the Higgs couplings to fermion pairs are included as well as, via an effective Lagrangian, the Δmb correction relevant at large tanβ.

•

Provides exact numerical solution of the Boltzmann equation by Runge-Kutta.

•

Outputs the relative contribution of each channel to 1/Ω.

•

Computes cross-sections for any 2→2 process at the parton level.

•

Calculates decay widths for all particles at tree-level including all 1→2 decay modes.

•

Calculates constraints on MSSM: Bs→μ⁺μ⁻ and NLO corrections to b→sγ.

Unusual features:Depending on the parameters of the model, the program generates additional new code for matrix elements, compiles it and loads it dynamically.Running time:0.2 sec.     

A computer program for two-particle generalized coefficients of fractional parentage

We present a FORTRAN90 program GCFP for the calculation of the generalized coefficients of fractional parentage (generalized CFPs or GCFP). The approach is based on the observation that the multi-shell CFPs can be expressed in terms of single-shell CFPs, while the latter can be readily calculated employing a simple enumeration scheme of antisymmetric A-particle states and an efficient method of construction of the idempotent matrix eigenvectors. The program provides fast calculation of GCFPs for a given particle number and produces results possessing numerical uncertainties below the desired tolerance. A single j-shell is defined by four quantum numbers, (e,l,j,t).A supplemental C++ program parGCFP allows calculation to be done in batches and/or in parallel.

Program summary

Program title:GCFP, parGCFPCatalogue identifier: AEBI_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEBI_v1_0.htmlProgram obtainable from: CPC Program Library, Queen's University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 17 199No. of bytes in distributed program, including test data, etc.: 88 658Distribution format: tar.gzProgramming language: FORTRAN 77/90 (GCFP), C++ (parGCFP)Computer: Any computer with suitable compilers. The program GCFP requires a FORTRAN 77/90 compiler. The auxiliary program parGCFP requires GNU-C++ compatible compiler, while its parallel version additionally requires MPI-1 standard librariesOperating system: Linux (Ubuntu, Scientific) (all programs), also checked on Windows XP (GCFP, serial version of parGCFP)RAM: The memory demand depends on the computation and output mode. If this mode is not 4, the program GCFP demands the following amounts of memory on a computer with Linux operating system. It requires around 2 MB of RAM for the A=12 system at Ex?2. Computation of the A=50 particle system requires around 60 MB of RAM at Ex=0 and ∼70 MB at Ex=2 (note, however, that the calculation of this system will take a very long time). If the computation and output mode is set to 4, the memory demands by GCFP are significantly larger. Calculation of GCFPs of A=12 system at Ex=1 requires 145 MB. The program parGCFP requires additional 2.5 and 4.5 MB of memory for the serial and parallel version, respectively.Classification: 17.18Nature of problem: The program GCFP generates a list of two-particle coefficients of fractional parentage for several j-shells with isospin.Solution method: The method is based on the observation that multishell coefficients of fractional parentage can be expressed in terms of single-shell CFPs [1]. The latter are calculated using the algorithm [2,3] for a spectral decomposition of an antisymmetrization operator matrix Y. The coefficients of fractional parentage are those eigenvectors of the antisymmetrization operator matrix Y that correspond to unit eigenvalues. A computer code for these coefficients is available [4]. The program GCFP offers computation of two-particle multishell coefficients of fractional parentage. The program parGCFP allows a batch calculation using one input file. Sets of GCFPs are independent and can be calculated in parallel.Restrictions:A<86 when Ex=0 (due to the memory constraints); small numbers of particles allow significantly higher excitations, though the shell with j?11/2 cannot get full (it is the implementation constraint).Unusual features: Using the program GCFP it is possible to determine allowed particle configurations without the GCFP computation. The GCFPs can be calculated either for all particle configurations at once or for a specified particle configuration. The values of GCFPs can be printed out with a complete specification in either one file or with the parent and daughter configurations printed in separate files. The latter output mode requires additional time and RAM memory. It is possible to restrict the (J,T) values of the considered particle configurations. (Here J is the total angular momentum and T is the total isospin of the system.) The program parGCFP produces several result files the number of which equals to the number of particle configurations. To work correctly, the program GCFP needs to be compiled to read parameters from the standard input (the default setting).Running time: It depends on the size of the problem. The minimum time is required, if the computation and output mode (CompMode) is not 4, but the resulting file is larger. A system with A=12 particles at Ex=0 (all 9411 GCFPs) took around 1 sec on a Pentium4 2.8 GHz processor with 1 MB L2 cache. The program required about 14 min to calculate all 1.3×¹⁰⁶ GCFPs of Ex=1. The time for all 5.5×¹⁰⁷ GCFPs of Ex=2 was about 53 hours. For this number of particles, the calculation time of both Ex=0 and Ex=1 with CompMode = 1 and 4 is nearly the same, when no other processes are running. The case of Ex=2 could not be calculated with CompMode = 4, because the RAM memory was insufficient. In general, the latter CompMode requires a longer computation time, although the resulting files are smaller in size. The program parGCFP puts virtually no time overhead. Its parallel version speeds-up the calculation. However, the results need to be collected from several files created for each configuration.References:[1] J. Levinsonas, Works of Lithuanian SSR Academy of Sciences 4 (1957) 17.[2] A. Deveikis, A. Bon?kus, R. Kalinauskas, Lithuanian Phys. J. 41 (2001) 3.[3] A. Deveikis, R.K. Kalinauskas, B.R. Barrett, Ann. Phys. 296 (2002) 287.[4] A. Deveikis, Comput. Phys. Comm. 173 (2005) 186. (CPC Catalogue ID. ADWI_v1_0)     

Including R-parity violation in the numerical computation of the spectrum of the minimal supersymmetric standard model: SOFTSUSY3.0

Current publicly available computer programs calculate the spectrum and couplings of the minimal supersymmetric standard model under the assumption of R-parity conservation. Here, we describe an extension to the SOFTSUSY program which includes R-parity violating effects. The user provides a theoretical boundary condition upon the high-scale supersymmetry breaking R-parity violating couplings. Successful radiative electroweak symmetry breaking, electroweak and CKM matrix data are used as weak-scale boundary conditions. The renormalisation group equations are solved numerically between the weak scale and a high energy scale using a nested iterative algorithm. This paper serves as a manual to the R-parity violating mode of the program, detailing the approximations and conventions used.

Program summary

Program title:SOFTSUSY v3.0Catalogue identifier: ADPM_v2_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/ADPM_v2_0.htmlProgram obtainable from: CPC Program Library, Queen's University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 75 927No. of bytes in distributed program, including test data, etc.: 570 916Distribution format: tar.gzProgramming language: C++, FortranComputer: Personal computerOperating system: Tested on Linux 4.xWord size: 32 bitsClassification: 11.6Catalogue identifier of previous version: ADPM_v1_0Journal reference of previous version: Comput. Phys. Comm. 143 (2002) 305Does the new version supersede the previous version?: YesNature of problem: Calculating supersymmetric particle spectrum and mixing parameters in the R-parity violating minimal supersymmetric standard model. The solution to the renormalisation group equations must be consistent with a high-scale boundary condition on supersymmetry breaking parameters and Rp parameters, as well as a weak-scale boundary condition on gauge couplings, Yukawa couplings and the Higgs potential parameters.Solution method: Nested iterative algorithmReasons for new version: This is an extension to the SOFTSUSY program which includes R-parity violating effects. The user provides a theoretical boundary condition upon the high-scale supersymmetry breaking R-parity violating couplings. Successful radiative electroweak symmetry breaking, electroweak and CKM matrix data are used as weak-scale boundary conditions. The renormalisation group equations are solved numerically between the weak scale and a high energy scale using a nested iterative algorithm. The paper serves as a manual to the R-parity violating mode of the program, detailing the approximations and conventions used.Restrictions:SOFTSUSY3.0 will provide a solution only in the perturbative regime and it assumes that all couplings of the MSSM are real (i.e. CP-conserving). The iterative SOFTSUSY algorithm will not converge if parameters are too close to a boundary of successful electroweak symmetry breaking, but a warning flag will alert the user to this fact.Running time: A few seconds per parameter point.     

SPICE: Simulation Package for Including Flavor in Collider Events

We describe SPICE: Simulation Package for Including Flavor in Collider Events. SPICE takes as input two ingredients: a standard flavor-conserving supersymmetric spectrum and a set of flavor-violating slepton mass parameters, both of which are specified at some high “mediation” scale. SPICE then combines these two ingredients to form a flavor-violating model, determines the resulting low-energy spectrum and branching ratios, and outputs HERWIG and SUSY Les Houches files, which may be used to generate collider events. The flavor-conserving model may be any of the standard supersymmetric models, including minimal supergravity, minimal gauge-mediated supersymmetry breaking, and anomaly-mediated supersymmetry breaking supplemented by a universal scalar mass. The flavor-violating contributions may be specified in a number of ways, from specifying charges of fields under horizontal symmetries to completely specifying all flavor-violating parameters. SPICE is fully documented and publicly available, and is intended to be a user-friendly aid in the study of flavor at the Large Hadron Collider and other future colliders.

Program summary

Program title: SPICECatalogue identifier: AEFL_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEFL_v1_0.htmlProgram obtainable from: CPC Program Library, Queen's University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 8153No. of bytes in distributed program, including test data, etc.: 67 291Distribution format: tar.gzProgramming language: C++Computer: Personal computerOperating system: Tested on Scientific Linux 4.xClassification: 11.1External routines: SOFTSUSY [1,2] and SUSYHIT [3]Nature of problem: Simulation programs are required to compare theoretical models in particle physics with present and future data at particle colliders. SPICE determines the masses and decay branching ratios of supersymmetric particles in theories with lepton flavor violation. The inputs are the parameters of any of several standard flavor-conserving supersymmetric models, supplemented by flavor-violating parameters determined, for example, by horizontal flavor symmetries. The output are files that may be used for detailed simulation of supersymmetric events at particle colliders.Solution method: Simpson's rule integrator, basic algebraic computation.Additional comments: SPICE interfaces with SOFTSUSY and SUSYHIT to produce the low energy sparticle spectrum. Flavor mixing for sleptons and sneutrinos is fully implemented; flavor mixing for squarks is not included.Running time: <1 minute. Running time is dominated by calculating the possible and relevant three-body flavor-violating decays of sleptons, which is usually 10-15 seconds per slepton.References:

[1]

B.C. Allanach, Comput. Phys. Commun. 143 (2002) 305, arXiv:hep-ph/0104145.

[2]

B.C. Allanach, M.A. Bernhardt, arXiv:0903.1805 [hep-ph].

[3]

A. Djouadi, M.M. Muhlleitner, M. Spira, Acta Phys. Pol. B 38 (2007) 635, arXiv:hep-ph/0609292.

     

Automatized analytic continuation of Mellin-Barnes integrals

This paper describe a package written in MATHEMATICA that automatizes typical operations performed during evaluation of Feynman graphs with Mellin-Barnes (MB) techniques. The main procedure allows to analytically continue a MB integral in a given parameter without any intervention from the user and thus to resolve the singularity structure in this parameter. The package can also perform numerical integrations at specified kinematic points, as long as the integrands have satisfactory convergence properties. It is demonstrated that, at least in the case of massive graphs in the physical region, the convergence may turn out to be poor, making naïve numerical integration of MB integrals unusable. Possible solutions to this problem are presented, but full automatization in such cases may not be achievable.

Program summary

Title of program: MBProgram summary URL:http://cpc.cs.qub.ac.uk/summaries/ADYG_v1_0Catalogue identifier: ADYG_v1_0Program obtainable from: CPC Program Library, Queen's University of Belfast, N. IrelandComputers: AllOperating systems: AllProgramming language used:MATHEMATICA, Fortran 77 for numerical evaluationMemory required to execute with typical data: Sufficient for a typical installation of MATHEMATICA.No. of lines in distributed program, including test data, etc.: 12 013No. of bytes in distributed program, including test data, etc.: 231 899Distribution format: tar.gzLibraries used:CUBA [T. Hahn, Comput. Phys. Commun. 168 (2005) 78] for numerical evaluation of multidimensional integrals and CERNlib [CERN Program Library, obtainable from: http://cernlib.web.cern.ch/cernlib/] for the implementation of Γ and ψ functions in Fortran.Nature of physical problem: Analytic continuation of Mellin-Barnes integrals in a parameter and subsequent numerical evaluation. This is necessary for evaluation of Feynman integrals from Mellin-Barnes representations.Method of solution: Recursive accumulation of residue terms occurring when singularities cross integration contours. Numerical integration of multidimensional integrals with the help of the CUBA library.Restrictions on the complexity of the problem: Limited by the size of the available storage space.Typical running time: Depending on the problem. Usually seconds for moderate dimensionality integrals.     

FLY. A parallel tree N-body code for cosmological simulations

FLY is a parallel treecode which makes heavy use of the one-sided communication paradigm to handle the management of the tree structure. In its public version the code implements the equations for cosmological evolution, and can be run for different cosmological models.This reference guide describes the actual implementation of the algorithms of the public version of FLY, and suggests how to modify them to implement other types of equations (for instance, the Newtonian ones).

Program summary

Title of program:FLYCatalogue identifier: ADSCProgram summary URL:http://cpc.cs.qub.ac.uk/summaries/ADSCProgram obtainable from: CPC Program Library, Queen's University of Belfast, N. IrelandComputer for which the program is designed and others on which it has been tested: Cray T3E, Sgi Origin 3000, IBM SPOperating systems or monitors under which the program has been tested: Unicos 2.0.5.40, Irix 6.5.14, Aix 4.3.3Programming language used: Fortran 90, CMemory required to execute with typical data: about 100 Mwords with 2 million-particlesNumber of bits in a word: 32Number of processors used: parallel program. The user can select the number of processors ?1Has the code been vectorized or parallelized?: parallelizedNumber of bytes in distributed program, including test data, etc.: 4 615 604Distribution format: tar gzip fileKeywords: Parallel tree N-body code for cosmological simulationsNature of physical problem:FLY is a parallel collisionless N-body code for the calculation of the gravitational force.Method of solution: It is based on the hierarchical oct-tree domain decomposition introduced by Barnes and Hut (1986).Restrictions on the complexity of the program: The program uses the leapfrog integrator schema, but could be changed by the user.Typical running time: 50 seconds for each time-step, running a 2-million-particles simulation on an Sgi Origin 3800 system with 8 processors having 512 Mbytes RAM for each processor.Unusual features of the program:FLY uses the one-side communications libraries: the SHMEM library on the Cray T3E system and Sgi Origin system, and the LAPI library on IBM SP system     

New version of PLNoise: a package for exact numerical simulation of power-law noises

In a recent paper I have introduced a package for the exact simulation of power-law noises and other colored noises [E. Milotti, Comput. Phys. Comm. 175 (2006) 212]: in particular, the algorithm generates 1/fα noises with 0<α?2. Here I extend the algorithm to generate 1/fα noises with 2<α?4 (black noises). The method is exact in the sense that it produces a sampled process with a theoretically guaranteed range-limited power-law spectrum for any arbitrary sequence of sampling intervals, i.e. the sampling times may be unevenly spaced.

Program summary

Title of program: PLNoiseCatalogue identifier:ADXV_v2_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/ADXV_v2_0.htmlLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlProgram obtainable from: CPC Program Library, Queen's University of Belfast, N. IrelandProgramming language used: ANSI CComputer: Any computer with an ANSI C compiler: the package has been tested with gcc version 3.2.3 on Red Hat Linux 3.2.3-52 and gcc version 4.0.0 and 4.0.1 on Apple Mac OS X-10.4Operating system: All operating systems capable of running an ANSI C compilerRAM: The code of the test program is very compact (about 60 Kbytes), but the program works with list management and allocates memory dynamically; in a typical run with average list length 2⋅¹⁰⁴, the RAM taken by the list is 200 KbytesExternal routines: The package needs external routines to generate uniform and exponential deviates. The implementation described here uses the random number generation library ranlib freely available from Netlib [B.W. Brown, J. Lovato, K. Russell: ranlib, available from Netlib, http://www.netlib.org/random/index.html, select the C version ranlib.c], but it has also been successfully tested with the random number routines in Numerical Recipes [W.H. Press, S.A. Teulkolsky, W.T. Vetterling, B.P. Flannery, Numerical Recipes in C: The Art of Scientific Computing, second ed., Cambridge Univ. Press., Cambridge, 1992, pp. 274-290]. Notice that ranlib requires a pair of routines from the linear algebra package LINPACK, and that the distribution of ranlib includes the C source of these routines, in case LINPACK is not installed on the target machine.No. of lines in distributed program, including test data, etc.:2975No. of bytes in distributed program, including test data, etc.:194 588Distribution format:tar.gzCatalogue identifier of previous version: ADXV_v1_0Journal reference of previous version: Comput. Phys. Comm. 175 (2006) 212Does the new version supersede the previous version?: YesNature of problem: Exact generation of different types of colored noise.Solution method: Random superposition of relaxation processes [E. Milotti, Phys. Rev. E 72 (2005) 056701], possibly followed by an integration step to produce noise with spectral index >2.Reasons for the new version: Extension to 1/fα noises with spectral index 2<α?4: the new version generates both noises with spectral with spectral index 0<α?2 and with 2<α?4.Summary of revisions: Although the overall structure remains the same, one routine has been added and several changes have been made throughout the code to include the new integration step.Unusual features: The algorithm is theoretically guaranteed to be exact, and unlike all other existing generators it can generate samples with uneven spacing.Additional comments: The program requires an initialization step; for some parameter sets this may become rather heavy.Running time: Running time varies widely with different input parameters, however in a test run like the one in Section 3 in the long write-up, the generation routine took on average about 75 μs for each sample.