Getting started with BSM Models

Basics

Herwig uses a Model class which:

  • stores the input parameters of model and calculates derived quantities;
  • provides access to the Feynman rules for the model to allow the calculation of hard processes and decays.

Obviously by default the StandardModel class which implements the parameters and Feynman rules of the Standard Model is used. In general setting up all the parameters and Vertex classes which implement the Feynman rules is complicated and a .model file is supplied which does all of this and sets replaces the StandardModel object used by default by that for the new physics model. In addition it creates the ParticleData objects for any new particles needed in the model, sets their branchings in the shower so that QCD radiation is generated and ensures they are decayed during the parton shower.

The first step of any BSM simulation is therefore reading the new model. We will use the built-in MSSM model as an example. There is an example input file LHC-MSSM.in provided with the release. In this case we start with

read MSSM.model

Often, particularly in SUSY models, many of the parameters of the model and decay modes of the new particles are read from a spectrum file calculated by an external spectrum generator. For example in the MSSM these are read using

setup [name of model]/Model [name of SLHA file]

Furthermore as Herwig includes the generation of additional radiation in many BSM decays using the POWHEG scheme it is useful to switch the generation of the parton shower to use these:

# Set emission to POWHEG for radiation in decays
set /Herwig/Shower/Evolver:HardEmissionMode POWHEG

Following this we need to specify which hard processes and decays to include in the simulation.

Calculation of Hard Processes

Herwig includes a built-in mechanism for the calculation of most hard scattering processes of interest in BSM models. Rather than implement matrix elements for specific scattering processes we include a mechanism where a range of HardProcessConstructor classes construct the scattering processes using the Feynman rules.

In general \(2\to2\) scattering processes are the most important. There are two mechanisms for generating these processes in Herwig

1. The TwoToTwoProcessConstructor class constructs general \(2\to2\) scattering processes based on the Feynman rules of the model. The default object created for this class is called HPConstructor. We therefore need to specify the incoming and outgoing particles for the scattering processes we wish to consider, for example for up and down left-handed squark production in the MSSM with the incoming proton only containing gluons, up and down quarks and antiquarks:

# Example hard process: Incoming proton, outgoing squarks

insert HPConstructor:Incoming 0 /Herwig/Particles/g
insert HPConstructor:Incoming 0 /Herwig/Particles/u
insert HPConstructor:Incoming 0 /Herwig/Particles/ubar
insert HPConstructor:Incoming 0 /Herwig/Particles/d
insert HPConstructor:Incoming 0 /Herwig/Particles/dbar

insert HPConstructor:Outgoing 0 /Herwig/Particles/~u_L
insert HPConstructor:Outgoing 0 /Herwig/Particles/~u_Lbar
insert HPConstructor:Outgoing 0 /Herwig/Particles/~d_L
insert HPConstructor:Outgoing 0 /Herwig/Particles/~d_Lbar

By default all processes with only the incoming particles, but any of the outgoing particles in association with any other particle are generated. There are a number of switches which control which specific processes are generated:

  • Processes controls the generation of the hard processes and specifically how the list of outgoing particles is interpreted in order to construct the relevant scattering processes. There are three options:

    1. SingleParticleInclusive the default value which requires at least one particle from the list of outgoing particles as an outgoing particle in the hard process;

    2. TwoParticleInclusive which requires that both the outgoing particles in the hard processes are in the list of outgoing particles;

    3. Exclusive which require that there are only two particles in the list of outgoing particles and that they are the outgoing particles in every hard process generated.

  • IncludeEW whether to include both electroweak (EW) and strong processes. By default it is set Yes in include both EW and strong processes although in many models it is reset to No so that only the dominant strong processes are generated to increase the speed of the calculations.

  • Excluded particles which are not allowed as s- or t-channel intermediates in the hard processes

  • ExcludedExternal particles which are not allowed external particles in the scattering processes.

  • ExcludedVertices vertices which are not to be used in the generation of the hard scattering processes.

2. The ResonantProcessConstructor class constructs \(2\to2\) scattering processes where a specific s-channel intermediate resonance is required. The default object created for this class is called ResConstructor. As before we need to specify the incoming and outgoing particles for the scattering processes as well as the possible s-channel resonances. For example from the built in model for Randell-Sundrum, from LHC-RS.in, if we wished to consider the production of the graviton decaying to \(e^+, W^+, Z^0,\gamma\) with the incoming proton only containing gluons, up and down quarks and antiquarks

# Example hard process: Incoming proton, outgoing graviton

insert ResConstructor:Incoming 0 /Herwig/Particles/g
insert ResConstructor:Incoming 0 /Herwig/Particles/u
insert ResConstructor:Incoming 0 /Herwig/Particles/ubar
insert ResConstructor:Incoming 0 /Herwig/Particles/d
insert ResConstructor:Incoming 0 /Herwig/Particles/dbar

insert ResConstructor:Intermediates 0 /Herwig/Particles/Graviton

insert ResConstructor:Outgoing 0 /Herwig/Particles/e+
insert ResConstructor:Outgoing 1 /Herwig/Particles/W+
insert ResConstructor:Outgoing 2 /Herwig/Particles/Z0
insert ResConstructor:Outgoing 3 /Herwig/Particles/gamma

By default all processes with only the incoming particles, but any of the outgoing particles in association with any other particle are generated. There are a number of switches which control which specific processes are generated:

  • Processes The setting described above are supported together with the additional Inclusive option where instead of using the list of outgoing particles all the processes are generated where the outgoing particles are those allowed for the decay of the on-shell intermediate.

In addition to the options described above it is possible to change the choice of the scale used for the hard processes using ScaleChoice and include a prefactor for the scale using ScaleFactor.

As well as the general mechanism for generating \(2\to2\) scattering processes we provide av small number of more specialised HardProcessConstructor classes for the generation of processes involving the Higgs bosons of BSM models:

  • HiggsVectorBosonProcessConstructor, the default object is HVConstructor, generates hard process for Higgs boson production in association with a vector boson;
  • HiggsVBFProcessConstructor, the default object is HiggsVBFConstructor, generates hard processes for Higgs boson production via vector boson fusion;
  • QQHiggsProcessConstructor, the default object is QQHiggsConstructor, generates hard processes for the production of the Higgs boson in association with a heavy quark-antiquark pair.

Calculation of Decays

Most particle in BSM models are unstable and decay. We therefore include the calculation of the allowed decay modes and their partial widths which allows us to calculate the total width and branching ratios for the various modes. In order to do this we include a number of classes inheriting from the NBodyDecayConstructorBase class to calculate different types of decay mode.

By default we use:

  • TwoBodyDecayConstructor, with an instance called TwoBodyDC, to generate \(1\to2\) decays;
  • ThreeBodyDecayConstructor, with an instance called ThreeBodyDC, to generate \(1\to3\) decays.

These classes construct all the \(1\to2,3\) decays consistent with the Feynman rules for the model and are switched on by default. In addition we have two more specific classes:

  • WeakCurrentDecayConstructor, with an instance called WeakDecayConstructor, for generating decays of the form \(a\to bW^*\) with a small mass difference between a and b so that the \(W^\pm\) boson is highly off-shell and decays to a small number of hadrons, the production of which is then described using the same weak currents as the decay of the \(\tau^\pm\) lepton;
  • FourBodyDecayConstructor, with an instance called FourBodyDC, for generating decays of the scalars to four fermions as this can be important for the Higgs boson in extended models and the decay of the stop in some SUSY scenarios;

which generate more specific types of decay which can be important in specific models but aren’t relevant in most cases and are switched off by default. N.B. as both of these simulate higher multiplicity decays the phase-space integration of the matrix elements has to be performed using the Monte Carlo technique and can therefore be slow if there are a lot of decay modes.