.. _Introduction: ############ Introduction ############ Sherpa is a Monte Carlo event generator for the Simulation of High-Energy Reactions of Particles in lepton-lepton, lepton-photon, photon-photon, lepton-hadron and hadron-hadron collisions. This document provides information to help users understand and apply Sherpa for their physics studies. The event generator is introduced, in broad terms, and the installation and running of the program are outlined. The various options and parameters specifying the program are compiled, and their meanings are explained. This document does not aim at giving a complete description of the physics content of Sherpa. To this end, the authors refer the reader to the original publications, :cite:`Gleisberg2008ta` and :cite:`Bothmann:2019yzt`. .. contents:: :local: .. _Introduction to Sherpa: ********************** Introduction to Sherpa ********************** `Sherpa `_ :cite:`Bothmann:2019yzt` is a Monte Carlo event generator that provides complete hadronic final states in simulations of high-energy particle collisions. The produced events may be passed into detector simulations used by the various experiments. The entire code has been written in C++, like its competitors `Herwig++ `_ :cite:`Bahr2008pv` and `Pythia 8 `_ :cite:`Sjostrand2007gs`. Sherpa simulations can be achieved for the following types of collisions: * for lepton--lepton collisions, as explored by the CERN LEP experiments, * for lepton--photon collisions, * for photon--photon collisions with both photons either resolved or unresolved, * for deep-inelastic lepton-hadron scattering, as investigated by the HERA experiments at DESY, and, * in particular, for hadronic interactions as studied at the Fermilab Tevatron or the CERN LHC. The list of physics processes that can be simulated with Sherpa covers all reactions in the Standard Model. Other models can be implemented either using Sherpa's own model syntax, or by using the generic interface :cite:`Hoeche2014kca` to the UFO output :cite:`Degrande2011ua` of `FeynRules`_ :cite:`Christensen2008py`,:cite:`Christensen2009jx`. The Sherpa program owes this versatility to the two inbuilt matrix-element generators, AMEGIC++ and `Comix `_, and to it's phase-space generator Phasic :cite:`Krauss2001iv`, which automatically calculate and integrate tree-level amplitudes for the implemented models. This feature enables Sherpa to be used as a cross-section integrator and parton-level event generator as well. This aspect has been extensively tested, see e.g. :cite:`Gleisberg2003bi`, :cite:`Hagiwara2005wg`. As a second key feature of Sherpa the program provides an implementation of the merging approaches of :cite:`Hoeche2009rj` and :cite:`Gehrmann2012yg`, :cite:`Hoeche2012yf`. These algorithms yield improved descriptions of multijet production processes, which copiously appear at lepton-hadron colliders like HERA :cite:`Carli2009cg`, or hadron-hadron colliders like the Tevatron and the LHC, :cite:`Krauss2004bs`, :cite:`Krauss2005nu`, :cite:`Gleisberg2005qq`, :cite:`Hoeche2009xc`. An older approach, implemented in previous versions of Sherpa and known as the CKKW technique :cite:`Catani2001cc`, :cite:`Krauss2002up`, has been compared in great detail in :cite:`Alwall2007fs` with other approaches, such as the MLM merging prescription :cite:`Mangano2001xp` as implemented in Alpgen :cite:`Mangano2002ea`, Madevent :cite:`Stelzer1994ta`, :cite:`Maltoni2002qb`, or Helac :cite:`Kanaki2000ey`, :cite:`Papadopoulos2005ky` and the CKKW-L prescription :cite:`Lonnblad2001iq`, :cite:`Lavesson2005xu` of Ariadne :cite:`Lonnblad1992tz`. This manual contains all information necessary to get started with Sherpa as quickly as possible. It lists options and switches of interest for steering the simulation of various physics aspects of the collision. It does not describe the physics simulated by Sherpa or the underlying structure of the program. Many external codes can be linked with Sherpa. This manual explains how to do this, but it does not contain a description of the external programs. You are encouraged to read their corresponding documentations, which are referenced in the text. If you use external programs with Sherpa, you are encouraged to cite them accordingly. The `MCnet Guidelines `_ apply to Sherpa. You are kindly asked to cite :cite:`Bothmann:2019yzt` if you have used the program in your work. The Sherpa authors strongly recommend the study of the manuals and many excellent publications on different aspects of event generation and physics at collider experiments written by other event generator authors. This manual is organized as follows: in :ref:`Basic structure` the modular structure intrinsic to Sherpa is introduced. :ref:`Getting started` contains information about and instructions for the installation of the package. There is also a description of the steps that are needed to run Sherpa and generate events. The :ref:`Input structure` is then discussed, and the ways in which Sherpa can be steered are explained. All parameters and options are discussed in :ref:`Parameters`. Advanced :ref:`Tips and Tricks` are detailed, and some options for :ref:`Customization` are outlined for those more familiar with Sherpa. There is also a short description of the different :ref:`Examples` provided with Sherpa. The construction of Monte Carlo programs requires several assumptions, approximations and simplifications of complicated physics aspects. The results of event generators should therefore always be verified and cross-checked with results obtained by other programs, and they should be interpreted with care and common sense. .. _Basic structure: *************** Basic structure *************** Sherpa is a modular program. This reflects the paradigm of Monte Carlo event generation, with the full simulation is split into well defined event phases, based on QCD factorization theorems. Accordingly, each module encapsulates a different aspect of event generation for high-energy particle reactions. It resides within its own namespace and is located in its own subdirectory of the same name. The main module called ``SHERPA`` steers the interplay of all modules -- or phases -- and the actual generation of the events. Altogether, the following modules are currently distributed with the Sherpa framework: ATOOLS This is the toolbox for all other modules. Since the Sherpa framework does not rely on CLHEP etc., the ATOOLS contain classes with mathematical tools like vectors and matrices, organization tools such as read-in or write-out devices, and physics tools like particle data or classes for the event record. METOOLS In this module some general methods for the evaluation of helicity amplitudes have been accumulated. They are used in AMEGIC++, the EXTRA_XS module, and the new matrix-element generator Comix. This module also contains helicity amplitudes for some generic matrix elements, that are, e.g., used by HADRONS++. Further, METOOLS also contains a simple library of tensor integrals which are used in the PHOTONS++ matrix element corrections. BEAM This module manages the treatment of the initial beam spectra for different colliders. The three options which are currently available include a monochromatic beam, which requires no extra treatment, photon emission in the Equivalent Photon Approximation (EPA) and - for the case of an electron collider - laser backscattering off the electrons, leading to photonic initial states. PDF The PDF module provides access to various parton density functions (PDFs) for the proton and the photon. In addition, it hosts an interface to the `LHAPDF `_ package, which makes a full wealth of PDFs available. An (analytical) electron structure function is supplied in the PDF module as well. MODEL This module sets up the physics model for the simulation. It initializes particle properties, basic physics parameters (coupling constants, mixing angles, etc.) and the set of available interaction vertices (Feynman rules). By now, there exist explicit implementations of the Standard Model (SM), its Minimal Supersymmetric extension (MSSM), the ADD model of large extra dimensions, and a comprehensive set of operators parametrizing anomalous triple and quartic electroweak gauge boson couplings. An Interface to `FeynRules`_ is also available. EXTRA_XS In this module a (limited) collection of analytic expressions for simple 2->2 processes within the SM are provided together with classes embedding them into the Sherpa framework. This also includes methods used for the definition of the starting conditions for parton-shower evolution, such as colour connections and the hard scale of the process. AMEGIC++ AMEGIC++ :cite:`Krauss2001iv` is Sherpa's original matrix-element generator. It employs the method of helicity amplitudes :cite:`Kleiss1985yh`, :cite:`Ballestrero1992dv` and works as a generator, which generates generators: During the initialization run the matrix elements for a given set of processes, as well as their specific phase-space mappings are created by AMEGIC++. Corresponding C++ sourcecode is written to disk and compiled by the user using the ``makelibs`` script or `scons `_. The produced libraries are linked to the main program automatically in the next run and used to calculate cross sections and to generate weighted or unweighted events. AMEGIC++ has been tested for multi-particle production in the Standard Model :cite:`Gleisberg2003bi`. Its MSSM implementation has been validated in :cite:`Hagiwara2005wg`. COMIX `Comix `_ is a multi-leg tree-level matrix element generator, based on the color dressed Berends-Giele recursive relations :cite:`Duhr2006iq`. It employs a new algorithm to recursively compute phase-space weights. The module is a useful supplement to older matrix element generators like AMEGIC++ in the high multiplicity regime. Due to the usage of colour sampling it is particularly suited for an interface with parton shower simulations and can hence be easily employed for the ME-PS merging within Sherpa. It is Sherpa's default large multiplicity matrix element generator for the Standard Model. PHASIC++ All base classes dealing with the Monte Carlo phase-space integration are located in this module. For the evaluation of the initial-state (laser backscattering, initial-state radiation) and final-state integrals, the adaptive multi-channel method of :cite:`Kleiss1994qy`, :cite:`Berends1994pv` is used by default together with a Vegas optimization :cite:`Lepage1980dq` of the single channels. In addition, final-state integration accomplished by Rambo :cite:`Kleiss1985gy`, Sarge :cite:`Draggiotis2000gm` and HAAG :cite:`vanHameren2002tc` is supported. CSSHOWER++ This is the module hosting Sherpa's default parton shower, which was published in :cite:`Schumann2007mg`. The corresponding shower model was originally proposed in :cite:`Nagy2005aa`, :cite:`Nagy2006kb`. It relies on the factorisation of real-emission matrix elements in the CS subtraction framework :cite:`Catani1996vz`, :cite:`Catani2002hc`. There exist four general types of CS dipole terms that capture the complete infrared singularity structure of next-to-leading order QCD amplitudes. In the large-N_C limit, the corresponding splitter and spectator partons are always adjacent in colour space. The dipole functions for the various cases, taken in four dimensions and averaged over spins, are used as shower splitting kernels. DIRE This is the module hosting Sherpa's alternative parton shower :cite:`Hoche2015sya`. In the Dire model, the ordering variable exhibits a symmetry in emitter and spectator momenta, such that the dipole-like picture of the evolution can be re-interpreted as a dipole picture in the soft limit. At the same time, the splitting functions are regularized in the soft anti-collinear region using partial fractioning of the soft eikonal in the Catani-Seymour approach :cite:`Catani1996vz`, :cite:`Catani2002hc`. They are then modified to satisfy the sum rules in the collinear limit. This leads to an invariant formulation of the parton-shower algorithm, which is in complete analogy to the standard DGLAP case, but generates the correct soft anomalous dimension at one-loop order. AMISIC++ AMISIC++ contains classes for the simulation of multiple parton interactions according to :cite:`Sjostrand1987su`. In Sherpa the treatment of multiple interactions has been extended by allowing for the simultaneous evolution of an independent parton shower in each of the subsequent (semi-)hard collisions. The beam--beam remnants are organized such that partons which are adjacent in colour space are also adjacent in momentum space. The corresponding classes for beam remnant handling reside in the PDF and SHERPA modules. AHADIC++ AHADIC++ is Sherpa's hadronization package, for translating the partons (quarks and gluons) into primordial hadrons, to be further decayed in HADRONS++. The algorithm bases on the cluster fragmentation ideas presented in :cite:`Gottschalk1982yt`, :cite:`Gottschalk1983fm`, :cite:`Webber1983if`, :cite:`Gottschalk1986bv` and implemented in the Herwig family of event generators. The actual Sherpa implementation, based on :cite:`Winter2003tt`, differs from the original model in several respects. HADRONS++ HADRONS++ is the module for simulating hadron and tau-lepton decays. The resulting decay products respect full spin correlations (if desired). Several matrix elements and form-factor models have been implemented, such as the Kühn-Santamaría model, form-factor parametrizations from Resonance Chiral Theory for the tau and form factors from heavy quark effective theory or light cone sum rules for hadron decays. PHOTONS++ The PHOTONS++ module holds routines to add QED radiation to hadron and tau-lepton decays. This has been achieved by an implementation of the YFS algorithm :cite:`Yennie1961ad`. The structure of PHOTONS++ is such that the formalism can be extended to scattering processes and to a systematic improvement to higher orders of perturbation theory :cite:`Schonherr2008av`. The application of PHOTONS++ therefore accounts for corrections that usually are added by the application of PHOTOS :cite:`Barberio1993qi` to the final state. SHERPA Finally, SHERPA is the steering module that initializes, controls and evaluates the different phases during the entire process of event generation. All routines for the combination of truncated showers and matrix elements, which are independent of the specific matrix element and parton shower generator are found in this module. The actual executable of the Sherpa generator can be found in the subdirectory ``/bin/`` and is called ``Sherpa``. To run the program, input files have to be provided in the current working directory or elsewhere by specifying the corresponding path, see :ref:`Input structure`. All output files are then written to this directory as well. .. _Feynrules: http://feynrules.irmp.ucl.ac.be/