PaperlayerView exact revision on arXiv

Source-linked AI summary

CalcHEP 3.4 for collider physics within and beyond the Standard Model

Alexander Belyaev, Neil D. Christensen, Alexander Pukhov

arXiv:1207.6082v2hep-phhep-ex

TL;DR

CalcHEP 3.4 addresses the need for automated, accessible collider calculations spanning model definitions, cross sections, decays, and event simulation. It combines symbolic and numerical sessions with a batch interface that connects production and decay processes, supports scans and parallelization, and produces LHE files. The authors conclude that the release is ready for Standard Model and BSM studies through GUI, batch, and HPC workflows.

  • Problem

    Collider studies require complex calculations connecting theoretical models to cross sections, decays, and multi-particle event files, while large scans and subprocess sets limit simpler batch workflows.

  • Method

    CalcHEP 3.4 combines symbolic matrix-element generation, numerical phase-space integration, event simulation, model-extension tools, and a batch interface for automated production-decay workflows.

  • Results

    The batch interface generates connected production-and-decay LHE events, supports parameter scans and processor parallelization, and includes example outputs of 16.9 fb and 0.517 fb total cross sections.

  • Takeaways & Limitations

    CalcHEP 3.4 is presented as a tool for Standard Model and BSM studies through interactive GUI, automated batch, and HEPMDB-based HPC workflows.

  • Takeaways & Limitations

    CalcHEP does not check the required symmetry of LorentzPart definitions for identical particles, whose absence leads to wrong results.

Abstract

from arXiv · show

We present version 3.4 of the CalcHEP software package which is designed for effective evaluation and simulation of high energy physics collider processes at parton level. The main features of CalcHEP are the computation of Feynman diagrams, integration over multi-particle phase space and event simulation at parton level. The principle attractive key-points along these lines are that it has: a) an easy startup even for those who are not familiar with CalcHEP; b) a friendly and convenient graphical user interface; c) the option for a user to easily modify a model or introduce a new model by either using the graphical interface or by using an external package with the possibility of cross checking the results in different gauges; d) a batch interface which allows to perform very complicated and tedious calculations connecting production and decay modes for processes with many particles in the final state. With this features set, CalcHEP can efficiently perform calculations with a high level of automation from a theory in the form of a Lagrangian down to phenomenology in the form of cross sections, parton level event simulation and various kinematical distributions. In this paper we report on the new features of CalcHEP 3.4 which improves the power of our package to be an effective tool for the study of modern collider phenomenology.

PROGRAM SUMMARY/NEW VERSION PROGRAM SUMMARY

CalcHEP 3.4 is a C-based package for collider-physics calculations, supporting Feynman-diagram evaluation and event generation across common workstation platforms.

  • CalcHEP 3.4 is written in C and runs on PC, Mac, and Unix workstations.
  • The package uses one processor for its graphical interface and can use available processors in batch mode.
  • Its resource requirements depend on the process under study.

1. Introduction

CalcHEP 3.4 provides an automated path from particle-physics models to collider predictions, combining an accessible GUI, model flexibility, numerical evaluation, and batch event production.

  • CalcHEP evaluates production cross sections and decay widths at lowest order across multiple particle-physics models, including effective models.
  • The package aims to move interactively from a Lagrangian to final distributions with high automation.
  • Its GUI and contextual help allow beginners to start using CalcHEP without prior experience.
  • Users can modify or create models internally or through external editors and cross-check calculations in Feynman and unitary gauges.
  • The symbolic and numerical modules calculate squared matrix elements, phase-space integrals, cross sections, decay widths, and cut-dependent kinematical distributions.
  • The batch interface automates production and decay calculations, combines them into LHE files, scans parameters, and parallelizes calculations across processors.

2. Installation

Installation involves unpacking and compiling CalcHEP, then creating a working directory with model, temporary, result, and binary subdirectories.

  • CalcHEP is designed for UNIX platforms and has been tested on Linux and Darwin.
  • The installation begins by unpacking the calchep_3.4.tgz archive into the calchep_3.4 directory.
  • Running gmake or make compiles the package and produces a success message when compilation completes.
  • The mkWORKdir command creates a calculation directory and assigns it as $WORK.
  • The working directory contains models/, tmp/, results/, and bin/ subdirectories.
  • The ./calchep and ./calchep_batch scripts launch graphical and batch sessions, respectively.

3. Interactive GUI symbolic session

The symbolic session provides menu-driven tools for model management, process construction, diagram generation, matrix-element calculation, and integration with external physics software.

  • Model and process setup: The symbolic menus support model selection, import, editing, syntax checking, and gauge selection before calculations.
  • Diagram construction: Users can define scattering and decay processes, generate and inspect Feynman diagrams, and exclude selected diagrams or squared diagrams.
  • Symbolic calculation: The session calculates squared matrix elements analytically, exports expressions, generates optimized C code, and launches numerical sessions.
  • New symbolic features: Version 3.4 adds 2 →1 processes, polarized massless initial fermions and vector bosons, and particles with spin up to 2.
  • External interfaces: Monte Carlo particle IDs connect models to parton distributions and external generators while basic checks help avoid clashes with known hadron identifiers.
  • Model extensions: SLHAplus, effective Higgs couplings, automatic widths, external libraries, and matrix-element libraries extend model constraints and interoperability.

4. Interactive GUI numerical session

The interactive numerical session provides GUI controls for configuring processes, phase-space integration, event generation, distributions, parton inputs, and particle properties. It uses VEGAS for Monte Carlo integration and supports model-dependent scales, cuts, external libraries, and SLHA output.

  • The numerical-session GUI lets users select subprocesses, set incoming momenta and helicities, modify model parameters, and view dependent parameters.
  • The session supports built-in and LHAPDF parton distributions, beam spectra, initial-state radiation, and external-library linking through the model Libraries table.
  • The Constraints menu calculates particle masses, widths, and branching ratios and writes complete SLHA files usable by external Monte Carlo programs.
  • Users can choose QCD normalization and factorization scales, apply kinematical cuts, and define phase-space mappings to improve Monte Carlo integration.
  • CalcHEP performs phase-space integration with VEGAS, generates partonic events, and produces one- or two-dimensional kinematical distributions that can be exported for external programs.
  • Built-in kinematical functions and user-defined C routines provide observables for cuts and distributions, with QCD-dependent effective masses available for Yukawa couplings.

5. Working with files from numerical session

CalcHEP records numerical-session state, distributions, and events in session-specific files that can be inspected, combined, converted, and mixed into decayed LHE event samples. Event mixing recursively applies decays while preserving decay histories, supporting metadata, and momentum conservation within numerical precision.

  • Session files: Session-specific files preserve parameters, random-generator state, integration results, distributions, and generated events for later use.The session number identifies related files, including prt_N, distr_N, and events_N.txt.
  • Distributions: Distributions from different sessions are combined only when their kinematic variables and distribution limits match exactly.Alias-based distributions such as M(jet,jet) can be combined when the alias is defined appropriately.
  • Event formats: CalcHEP converts generated events to LHE format and provides routines to histogram both native and LHE event files.For LHE inputs, histogram commands use particle PDG IDs because particle names are absent.
  • Event mixing: event_mixer combines production and decay events recursively, stores decay histories and lifetimes, and can attach SLHA data for downstream shower and detector tools.The resulting LHE metadata supports hadronisation and detector simulation, while SLHA tags allow Pythia and Herwig to implement BSM decays.
  • Event mixing: Breit-Wigner decay-mass smearing preserves momentum conservation, with typical deviations around 10^-10 relative to total energy.An example records maximum deviations of 7.9E-11, 1.3E-12, 1.3E-12, and 8.0E-11.
  • Event metadata: The mixed LHE file includes a HepML XML header that supports automatic uploading to the CERN Monte-Carlo Database.The header can also include run_details.txt information when that file is present.

6. CalcHEP blind mode and batch scripts

CalcHEP’s blind mode converts interactive GUI actions into reusable command sequences, while accompanying scripts automate parameter changes, scans, subprocess calculations, and event generation. These tools support unattended batch workflows but report failures through shell errors and return codes.

  • Blind mode: Blind mode interprets a command string as the keystrokes of an interactive CalcHEP session, enabling non-interactive process generation.The +blind mode records a user’s GUI command sequence so it can later be reused or modified with -blind.
  • Session preparation: Parameter-setting scripts update incoming momenta or independent model parameters and then terminate, allowing numerical sessions to be prepared without interaction.Updated parameters are retained in session.dat for subsequent GUI or script runs.
  • Automation scripts: name_cycle scans a model parameter and records the resulting cross-sections, while subproc_cycle evaluates cross-sections and generates events for subprocesses.Scan inputs and outputs use tabular files whose rows represent parameter points.
  • Parameter scans: par_scan evaluates parameter points separately, whereas par_scan_sum evaluates all available subprocesses and sums their cross-sections.The results can be redirected to an output file and include an additional calculation-results column.
  • Event generation: gen_events generates a requested number of events after a successful VEGAS calculation with a frozen integration grid.The requested count is specified by the Nevents argument.
  • Error handling: Scripts signal errors through stderr and expose their return values through the shell, with possible error codes documented in the CalcHEP manual.This provides a command-line mechanism for detecting failed calculations.

7. Batch interface

The batch interface extends CalcHEP’s non-interactive workflow to large calculations involving multiple subprocesses, parameter scans, production and decay chains, and parallel execution. It combines results into retrievable event and distribution files while exposing progress through browser-readable reports.

  • Motivation and input: The batch interface addresses limitations of shell scripts for large calculations involving parameter scans, many subprocesses, and parallelization.Its input is a text batch file containing keywords and values for the calculation.
  • Code management: A subprocess-code library reuses existing numerical code and regenerates code only when requested code is absent or the model changes.This avoids repeating the often lengthy code-generation step.
  • Calculation pipeline: The interface integrates phase-space calculations, event generation, subprocess combination, and production-decay connection into fully decayed LHE output usable by Monte Carlo software.The resulting event file is intended for Pythia or other software.
  • Parameter scans: Multiple model parameters can be scanned, with combined results stored under names unique to each parameter point.This naming supports later retrieval of scan results.
  • Parallelization: Symbolic and numerical calculations are parallelized across subprocesses and parameter points on multicore machines, PBS clusters, and LSF clusters.The user sets the number of cores and cluster software, enabling use of hundreds or thousands of processors.
  • Monitoring: HTML and text progress reports show completed results and link to event, session.dat, and prt files while the calculation runs unattended.The interface can run in the background and be checked periodically.
  • Batch configuration: Batch files specify models, processes, decays, aliases, PDFs, kinematics, gauges, and optional virtual W/Z decay behavior.Multiple processes and decays can be listed, while cuts and distributions do not apply to decays.
  • Outputs: Batch results can include LHE events, PAW ntuples, raw distribution data, and PNG plots, depending on the requested options and available tools.Output filenames are derived from the batch-file name and scan values.

8. Particle interaction model implementation

CalcHEP represents particle-interaction models through structured tables for parameters, particles, vertices, and supporting libraries. Its implementation separates independent and dependent quantities while supporting automatic widths, model constraints, particle properties, and external-function integration.

  • Model structure: CalcHEP stores each interaction model in five tables covering parameters, constraints, particles, vertices, and libraries.The corresponding files are located in WORK/models/ and use model-numbered filenames.
  • Parameters: Independent parameters store names, numerical values, and comments, while dependent parameters are defined through formulas using model parameters and supported functions.Formulas may include arithmetic operators, standard C mathematics functions, SLHAplus routines, conditional functions, and user-defined library functions.
  • Special parameters: CalcHEP reserves GG for the strong coupling and Q as a scale parameter used in effective quark masses and Yukawa couplings.The strong coupling is evaluated from QCD parameters, while Q is set to the decaying particle’s mass during width calculations.
  • Dependent parameters: For large models, CalcHEP divides dependent parameters into public and local sets and compiles only the subset needed for the current calculation unless additional parameters are forced in.Public parameters support masses, widths, external functions, cuts, histogram limits, and QCD-scale specifications.
  • Particles: Particle entries specify names, antiparticles, PDG codes, spin, mass, width, color, and related properties, with unstable widths optionally calculated automatically.Automatic width evaluation first searches for 1 →2 decays and then considers 1 →3 decays if needed.

9. Tools for model implementation and the model repository at HEPMDB

CalcHEP 3.4 extends model implementation through SLHAplus interfaces and routines for external spectra, parameter files, mass-matrix diagonalization, running couplings, and effective Higgs interactions. These tools connect model data and loop-informed quantities to CalcHEP calculations.

  • SLHAplus: SLHAplus reads SLHA parameter files, supports on-the-fly mass-matrix diagonalization, and provides tools for implementing model constraints.It is intended for models where loop corrections to particle masses are important and can interface with external spectrum calculators.
  • SLHA input: The slhaRead mode combines flags controlling whether new data replace old data, input mistakes stop processing, and DECAY or BLOCK data are read.The mode is expressed as m1 + 2m2 + 4m4 + 8m8.
  • SLHA input: The slhaVal function retrieves values from named SLHA blocks using a specified scale and block-entry structure.Its arguments include the block name, scale, number of parameters per line, and the requested parameters.
  • Effective Higgs interactions: CalcHEP 3.4 adds SLHAplus calculations for effective Higgs-photon-photon and Higgs-gluon-gluon couplings induced by charged or colored particles in loops.The implementation includes CP-even and CP-odd effective interaction forms and functions for loop contributions and QCD corrections.
  • Effective Higgs interactions: For effective Higgs couplings, CalcHEP combines complex operator couplings and assigns the absolute value of their sum to the effective coupling parameter.The stated prescription follows summation over amplitudes before squaring and diagram summation.

QCD corrections for hgg coupling

CalcHEP incorporates QCD corrections for hGG-related calculations and compares Higgs decay results with Hdecay. The section also illustrates model implementation through the Inert Doublet Model and external model-building tools.

  • QCD corrections for hgg coupling: CalcHEP presents QCD corrections for hGG partial widths and cross sections rather than effective vertices because infrared divergences cancel between real and virtual contributions.Users must implement the NLO factors at vertices for effective-vertex treatments.
  • QCD corrections for hgg coupling: The hGG heavy-quark-loop QCD correction is known through NNLO, while massive-fermion-loop corrections are reported at approximately 1%.The cited massive-loop estimate applies when M_f >> M_h/2.
  • QCD corrections for hgg coupling: Scalar color-particle loop corrections are known at NLO and are reported as 17/6 times larger than the F_qq correction.The example includes SUSY squarks as scalar color particles.
  • QCD corrections for hgg coupling: For hGG, CalcHEP gives a slightly smaller result than Hdecay because Hdecay includes NNNLO QCD and QCD-EW corrections.At a Higgs mass of 120 GeV, the corrections are 1% and 5%, respectively, with the latter depending on the model.
  • QCD corrections for hgg coupling: CalcHEP includes Higgs decays through virtual W/Z bosons, enabling branching-ratio comparisons, and its Higgs-width results are compared with Hdecay and theoretical uncertainties.The comparison is presented for Standard Model Higgs partial widths.
  • Model implementation: LanHEP and FeynRules generate CalcHEP model files from Lagrangians, reducing the burden of manually implementing hundreds or thousands of Feynman rules.The paper demonstrates model construction and compilation through LanHEP and describes analogous FeynRules implementation.
  • Model implementation: The Inert Doublet Model example adds a new SU(2) × U(1) scalar doublet whose lightest new particle is stable because of an H2 → −H2 symmetry.The model is implemented using independent masses and couplings, with additional parameters expressed from them.
  • HEPMDB: HEPMDB collects models for multiple matrix-element generators, provides source code and HPC submission, and supports cross-checking implementations across generators and gauges.Its web interface returns submitted calculation results and lets users focus on physics rather than installation and setup.

10. Using CalcHEP as a matrix elements generator for other packages.

CalcHEP 3.4 can expose generated squared-matrix-element code to external programs through dynamically linked libraries. Users select models, update parameters, and compile or link process code for external calculations.

  • Dynamic matrix elements: CalcHEP includes code for generating and dynamically linking new processes so optimized squared matrix elements can be used by external packages or user programs.This functionality was first written for micrOMEGAs.
  • Dynamic matrix elements: Users create a main C program and compile it with the make_main script, which collects the required libraries into an executable.The paper provides an example source file and compilation command.
  • Model selection: The model is selected with setModel, which takes the models-directory path and model number and creates an auxiliary CalcHEP working directory.A successful call returns 0.
  • Model selection: Multiple models can be used in one main function, but changing models cleans the auxiliary directory and removes libraries that must then be recreated.This is an explicit operational limitation of multi-model use.
  • Parameter updates: Independent model parameters can be assigned directly or read from a two-column text file, after which dependent parameters are recalculated and errors identify the affected parameter or input line.The relevant interfaces are assignVal, readVar, and the dependent-parameter update function.
  • Parameter updates: Updated parameter values can be queried by name through findVal and findValW, which return or report the requested numerical value.findVal returns a nonzero value if the parameter cannot be found, while findValW prints an error.

10.4. Model Particles

CalcHEP provides programmatic access to model particles, parameters, widths, decay channels, and branching fractions. These interfaces support querying particle properties and calculating or exporting decay information.

  • Particle properties: Particle names and PDG codes can be converted in either direction, with unsuccessful lookups returning NULL or 0.The interfaces map between the model’s particle naming and PDG-code representations.
  • Particle properties: qNumbers returns twice the spin, three times the electric charge, and the color representation for a named particle.Allowed color representations are 1, 3, −3, and 8.
  • Particle properties: The pMass function returns a particle’s numerical mass from its name.The interface takes the particle name as its input.
  • Model data: Model parameters are exposed through arrays containing independent and public dependent parameter names and values.The arrays reserve element zero and use REAL, which defaults to double precision.
  • Model data: Particle model data can also be accessed directly through the number of particles and the ModelPrtcls array.The particle-structure type is defined in VandP.h.
  • Widths and branchings: pWidth calculates a particle width and fills a decay-channel list, while findBr extracts the branching ratio for a specified final state.The final-state pattern is a comma-separated list of particle names, and order is unimportant.
  • Widths and branchings: If no SLHA width is supplied, CalcHEP evaluates open 1 → 2 decay channels first and then open 1 → 3 channels when the resulting width is zero.Widths and complete branching lists can be written in SLHA format with slhaDecayPrint.

10.7. Processes

CalcHEP dynamically generates, compiles, and links collision or decay process libraries. The process interfaces expose subprocess counts, particle identities, and masses for use in external programs.

  • Process generation: CalcHEP dynamically generates and links code for collision or decay processes through a process-library interface.The section introduces additional functions for inspecting dynamically linked processes.
  • Process generation: getMEcode accepts flags and process specifications that control widths, gauge choice, excluded internal particles, excluded final-state particles, and library naming.The UG flag forces unitary-gauge calculations, while exclusion lists remove selected particles from diagrams or final states.
  • Process generation: If a named library exists, CalcHEP links it without checking whether it contains the requested process; otherwise it generates, compiles, and stores the library.Users must ensure that library names are used correctly because existing libraries are not validated against the requested process.
  • Process generation: newProcess provides a simplified interface equivalent to getMEcode with default flags and automatically generated library names.It sets twidth and UG to zero and leaves exclusion lists unset.
  • Parameter consistency: Before using dynamically linked process code, users must export the current numerical parameter values to that code.The generated process parameters are not automatically related to the values set through the earlier parameter interfaces.
  • Process inspection: procInfo1 reports the number of subprocesses and incoming and outgoing particle counts, while procInfo2 returns particle names and masses for a selected subprocess.Both functions return zero when successful.

10.8. Matrix elements

CalcHEP exposes generated matrix elements through C and C++ interfaces, allowing users to evaluate squared matrix elements at specified phase-space points and integrate processes numerically. The section also demonstrates compiling and loading these interfaces under Root.

  • Matrix-element generation: The symbolic workflow generates and compiles C code into an executable numerical module for matrix-element evaluation.The numerical module evaluates phase-space integrals for cross sections or decay widths and can produce distributions with cuts.
  • C interface: The sqme interface takes a subprocess index, strong coupling, four-momentum array, and error-code pointer, returning the squared matrix element.The momentum array contains 4·(nin + nout) elements, with each particle represented by energy followed by three momentum components.
  • C interface: The phase-space input is organized as consecutive four-momenta, while the subprocess index selects the subprocess and the error code reports failures.The interface assumes incoming-particle polarizations have already been handled.
  • Root interface: CalcHEP provides a C++ class wrapper for Root that exposes model setup, parameter assignment, particle properties, widths, branching ratios, and matrix-element generation.The wrapper uses capitalized C++ functions and stores shared state such as the model list and generated numerical object.
  • Root interface: A shared library named ch_root.so can be compiled for Root, and the supplied Root example is expected to reproduce the C-program output.The library is built from the CalcHEP Root directory after specifying the Root installation path.

11. Batch file examples with results

The batch examples show CalcHEP automating cross-section calculations, event generation, parameter scans, diagram selection, and numerical-session reporting. Results are exposed through browser pages and text files for verification and further inspection.

  • Examples and workflow: The batch examples provide complete inputs and outputs that users can use to test installations or adapt as templates.The examples assume CalcHEP is installed and a WORK directory has been created.
  • e+e−→Zh: The e+e−→Zh batch evaluates the process at √s = 1 TeV with ISR and Beamstrahlung effects and generates 10K LHE events.The events are written to ee_zh-single.lhe, and the reported total cross section is 16.9 fb.
  • Diagram selection and regularization: The e+e−→hµ+µ−→µ+µ−b¯b example removes diagrams outside e+e−→Zh and uses regularization to treat the Z-boson resonance peak more efficiently.The batch is run with calchep_batch batch_file_2 and produces 10K events with a µ+µ−b¯b final state.
  • Diagram selection and regularization: 0.517 fb is the reported total cross section for the µ+µ−b¯b final state, with 10K events written to ee_mmh_mmbb-single.lhe.The browser output is intended to agree with Fig. 5.
  • Parameter scans and reporting: The pp→Wb¯b→ℓνb¯b batch scans the Higgs mass using Mh values 120, 125, and 130 GeV, generating 10000 events per run step.The scan results are displayed in a browser, while clicking Mh=120 opens detailed numerical-session results and requested distributions.
  • Parameter scans and reporting: Batch results shown in the HTML browser are also recorded in plain-text files under $WORK/html, including numerical.txt and files in the runs directory.These files contain additional numerical-session details.
  • Parameter scans and reporting: The e+e−→Zh scan reports cross sections of 1.2610e+03, 1.2510e+03, and 1.2440e+03 fb for Mh120, Mh125, and Mh130, respectively.Each scan point finished with 13/13 sessions and generated 10000 events.

12. Conclusions and outlook

CalcHEP 3.4 supports interactive, batch, and HEPMDB-based workflows for Standard Model and BSM studies, while also allowing new models through external tools. The outlook lists planned improvements for regularization, spin handling, jet matching, helicity amplitudes, and parallel numerical sessions.

  • Capabilities: CalcHEP 3.4 supports interactive GUI studies, automated and parallelized batch calculations, and HEPMDB-based parameter scans with LHE-file generation.The GUI exposes process anatomy and interference details, while batch workflows connect production and decay processes during event generation.
  • Models: Many BSM models are available through HEPMDB, and new models can be implemented using LanHEP and FeynRules.The paper presents these resources as making BSM model exploration and extension accessible within CalcHEP.
  • Outlook: Planned developments include automatic regularization, polarization projections, spin correlations, jet matching, helicity amplitudes, and improved parallelized numerical sessions.The proposed changes target larger final-state multiplicities and more complete production–decay connections.
Loading 1207.6082v2…