text:
# Dimensionality effects on non-equilibrium electronic transport in Cu nanobridges

## Abstract

We report on non-equilibrium electronic transport through normal-metal (Cu) nanobridges coupled to large reservoirs at low temperatures. We observe a logarithmic temperature dependence of the zero-bias conductance, as well as a universal scaling behavior of the differential conductance. Our results are explained by electron-electron interactions in diffusive metals in the zero-dimensional limit.

In clean bulk metals, the electron-electron interaction, although strong, is screened sufficiently to make an independent electron picture valid for a broad range of materials. In disordered metals, however, screening is limited by the diffusive motion of electrons, leading to a well-known correction to the linear conductance and to the one-particle density of states (DOS) near the Fermi level Altshuler and Aronov (1985). The corrections depend on dimensionality, and for the DOS are proportional to $`\sqrt{ϵ}`$, $`\mathrm{ln}^2ϵ`$ and $`\sqrt{ϵ}^1`$ in three, two and one dimensions, respectively, where $`ϵ`$ is the energy difference to the Fermi level, and logarithmic corrections to leading power laws have been omitted. The DOS correction is spectroscopically resolved as a zero-bias anomaly (ZBA) in tunneling experiments. For metallic point contacts, the occurrence of ZBAs has been reported in the literature for a long time Yanson and Shklyarevskii (1986); Ralph et al. (1994); Anaya et al. (2003); Yu and Natelson (2003), and attributed to various physical mechanisms like Kondo scattering by magnetic impurities, two-channel Kondo scattering by two-level systems, or Coulomb interaction.

In our previous work Weber et al. (2001), we have presented transport measurements on thin, short metallic films connected to large reservoirs. In these films, all inelastic scattering lengths were much larger than the sample size, such that a well-defined non-equilibrium distribution function with a double-step Pothier et al. (1997) in the electronic system can be assumed. The elastic mean free path was of the order of the film thickness, while the lateral dimensions of the films were much larger, i.e. the diffusive random-walk of the electrons is essentially two-dimensional (2D). We observed a logarithmic temperature dependence of the linear conductance, and a ZBA in the differential conductance which obeyed a parameter-free scaling relation with a logarithmic energy dependence. From a careful analysis of the energy and magnetic-field dependence and the reproducible amplitude of the ZBA, independent of sample preparation, we ruled out an explanation based on Kondo or two-channel Kondo physics for the anomaly observed in our samples. Our results were explained theoretically based on the Aharonov-Altshuler corrections in two dimensions extended to the non-equilibrium situation in a finite-size sample. Recently, further theoretical work on Coulomb interaction in non-equilibrium transport of metallic nanobridges Golubev and Zaikin (2001) has been reported. A logarithmic correction to the conductance, and a scaling form indistinguishable from our results, is predicted. These results are found to be independent of microscopic details, as long as the sample is fully phase coherent. Especially, the predictions are not specific to a two-dimensional thin film sample. We have therefore extended our investigation to clarify the dependence of the logarithmic ZBA on dimensionality by changing the sample geometry.

The samples presented in this study were prepared by e-beam lithography and shadow-evaporation techniques. A silicon wafer with 600 nm of thermal oxide was coated with two layers of e-beam resist, with the lower layer being PMMA/MAA and the upper layer PMMA 950K. Then, a mask with large areas for the reservoirs and a thin slit for the bridge was defined by e-beam lithography. 250 nm of Cu was evaporated under an angle of $`13^{}`$ through the mask, forming the reservoirs, contact leads and a shadow of the bridge unconnected to the rest of the structure. Then, the bridge was evaporated under an angle of $`10^{}`$ through the mask, closing the gap between the reservoirs. Here, the thick Cu layer on top of the resist resulting from the first evaporation somewhat narrows the slit left for the bridge, allowing for bridges down to approximately 20 nm width. After lift-off the samples were quickly mounted into a dilution refrigerator. Total exposure time to air was kept to less than 30 minutes in order to minimize oxide formation. The zero-bias resistance was measured using an AC resistance bridge. Care was taken to keep the excitation amplitude below the thermal energy scale. For the differential resistance measurements, an additional DC current was applied. Measurements were carried out at temperatures between 0.1 and 3 K and with magnetic fields of up to 12 T applied perpendicular to the substrate plane. We present data of two samples, Cu1 and Cu2, with parameters given in Table 1. The mean free path $`l`$ was obtained from $`\rho l`$, and the diffusion constant $`D`$ from Einstein’s relation $`\rho ^1=Ne^2D`$, where $`\rho `$ is the resistivity of the bridge, and $`N`$ the density of states at the Fermi level. The material parameters were taken from Ashcroft and Mermin (1976). From $`D`$, the Thouless energy $`E_{\mathrm{Th}}=hD/L^2`$ was calculated.

To check whether the measurements indeed establish a well-defined non-equilibrium with negligible inelastic scattering, differential resistance measurements were carried out to bias voltages up to 30 mV in order to observe point contact spectra. These high-bias data are plotted in Fig. 2 as $`d^2U/dI^2`$ vs. $`U`$. The data clearly exhibit peaks at $`15\mathrm{mV}`$, followed by a broad shoulder. These peaks can be related to backscattering by optical phonons in the reservoirs, and are consistent with published results for copper point contacts in the diffusive regime Yanson and Shklyarevskii (1986). The observation of well-resolved point contact spectra at bias voltages an order of magnitude beyond the regime of the ZBA clearly shows that broadening of the energy distribution due to self-heating is small. Independently, we have estimated the effective temperature due to self-heating in a model similar to that presented in Ref. Henny et al. (1999), and found a negligible temperature rise compared to the bias voltage.

In Fig. 3, the temperature dependence of the zero-bias conductance of the two samples is shown. Both display a logarithmic temperature dependence in a temperature range from 0.2 K to 1.2 K. The data can be fitted with

$$G(0,T)=G(0,T_0)+A\mathrm{ln}(T/T_0),$$
(1)
where $`G`$ is the conductance, $`T`$ the temperature and $`T_0`$ an arbitrary reference temperature. The amplitude $`A`$ in zero applied magnetic field is about 0.56 $`e^2/h`$ for both samples. For sample Cu1, measurements were performed in a magnetic field $`B=12\mathrm{T}`$, where the amplitude is reduced to 0.40 $`e^2/h`$.

The scaling form

$$\frac{G(U,T)G(0,T)}{A}=\mathrm{\Phi }\left(\frac{eU}{k_\mathrm{B}T}\right)$$
(2)
is employed to describe our data Weber et al. (2001). Here, $`U`$ is the applied voltage, $`k_\mathrm{B}`$ the Boltzmann constant, and $`\mathrm{\Phi }`$ is a universal function. This formula suggests rescaling and plotting the data as $`(G(U)G(U=0))/A`$ vs. $`eU/k_\mathrm{B}T`$. Such scaling plots of the data for samples Cu1 and Cu2 are shown in Figs. 4 and 5. As can be seen, the data of both samples collapse onto a common function $`\mathrm{\Phi }`$ in the low bias regime, whereas for larger bias, deviations with a reproducible dependence on $`eU`$ instead of $`eU/k_\mathrm{B}T`$ are observed. The onset of these deviations is consistent with our estimate of the Thouless energy. These deviations are presumably voltage-dependent universal conductance fluctuations (VUCF), and can also be seen as small wiggles in the point contact spectra in Fig. 2, where the ZBA itself is resolved as a steep negative slope around zero bias.

The universal scaling function $`\mathrm{\Phi }`$ has been calculated by means of a tunneling Hamiltonian, which couples the interacting diffusive metal to ideal leads Weber et al. (2001). As the bridge is shorter than all inelastic scattering length scales, the bias voltage is expected to create a non-equilibrium double-step distribution function in the electronic system, leading to a spectroscopic resolution of interaction corrections to the density of states. It was shown that the $`\mathrm{ln}^2ϵ`$ dependence of two-dimensional films is effectively cut off to a simple $`\mathrm{ln}ϵ`$ dependence, as only the lowest lying diffusion mode is relevant for our finite-length samples as long as energies below the Thouless energy are considered. A similar treatment Schwab and Raimondi (2002) confirms this result, and predicts the amplitude $`A`$ of the anomaly to be in the range $`0.250.5e^2/h`$, depending on the transparency of the bridge-to-lead interface.

An alternative treatment of the ZBA in a coherent conductor in series with an environmental impedance has been given by Golubev et al. Golubev and Zaikin (2001) and Yeyati et al. Yeyati et al. (2001). In this case, the ZBA is interpreted as a residue of the well known Coulomb blockade in the limit of high transparency. The theory does not depend on microscopic details or the extent of the conductor, as long as it is phase-coherent. A logarithmic temperature dependence is predicted, along with a scaling function that is numerically indistinguishable from (2) Golubev and Zaikin (2001). The amplitude $`A`$ is predicted to be 2/3 $`e^2/h`$ for a diffusive conductor, in which case the resistance of the conductor itself serves as the environmental impedance.

For our present study, we deliberately varied the dimensionality of the diffusive motion compared to our previous work: Width, height and mean free path are approximately equal, thus the nanobridges are now short wires (1D) instead of films (2D). Nonetheless, the logarithmic temperature dependence and scaling behavior calculated for the short films is observed, with an amplitude $`A0.40.5e^2/h`$ in agreement with the range of the predicted values Golubev and Zaikin (2001); Schwab and Raimondi (2002). We find that the scaling behavior is valid in the bias voltage range defined by the Thouless energy. We therefore conclude that the lateral dimensions of the sample compared to the mean free path, and therefore the dimensionality of the diffusive motion, are irrelevant, as long as $`W,H,L<\sqrt{hD/\mathrm{max}(eU,k_\mathrm{B}T)}`$, and only the lowest lying diffusion mode is realized. Thus, even though it employs a film or wire geometry, our experiment effectively constitutes the zero-dimensional limit of electron-electron interaction. This fact has been pointed out by a theoretical treatment similar to our previous work Schwab and Raimondi (2002). The consistency with the results of Golubev et al. Golubev and Zaikin (2001) demonstrates the close relationship between the environmental Coulomb interaction and the electron-electron interaction in diffusive metals, which has recently been demonstrated in a tunneling experiment Pierre et al. (2001).

To conclude, we have presented transport measurements on short, phase-coherent metallic wires in a well-defined electronic non-equilibrium situation. We find the same logarithmic temperature dependence and scaling behavior as observed previously in short films. We therefore identify our results with electron-electron interactions in a diffusive metal in the zero-dimensional limit. Our experiment demonstrates the close relation between electron-electron interaction in diffusive metals and the environmental Coulomb interaction.

###### Acknowledgements.

Useful discussions with P. Schwab, J. Kroha and A. Zaikin are gratefully acknowledged, as well as the support of M. Brückel in the sample fabrication.


format: text

text:
# MAGNETIZATION OF CHARGE-ORDERED La2-xSrxNiO4+δ

## Abstract

We report magnetization measurements on La2-xSrxNiO4+δ single crystals, with $`0x0.5`$. Glassy behaviour associated with the formation of spin-charge stripes, and a separate spin-glass phase at low temperatures were observed. We have also found a ‘memory effect’ in the magnetic field – temperature history, which is found to be suppressed in the low temperature spin state of the $`x=0.33`$ crystal.

Spin and charge ordering in the form of stripes has been observed in a number of doped antiferromagnets, particularly in layered transition-metal oxides such as cuprates and nickelates. The possibility that stripe correlations play an important role in the mechanism of high-$`T_\mathrm{c}`$ superconductivity makes it important to understand the properties of the stripe phase.

In La2-xSrxNiO4+δ (LSNO) the charges order into periodically spaced lines of charges that lie at 45 to the Ni-O bonds. At lower temperatures the Ni2+ spins order antiferromagnetically between the charge-stripes that act as antiphase domain walls to the magnetic order. These studies have also revealed commensurability effects occurring only in the 1/3 and 1/2 doped materials. Previous work has also found a spin glass state exists at low temperatures in LSNO. Here we report magnetization measurements that reveal other types of glassy behaviour in these materials, including a field ‘memory effect’ in the spin glass state.

We performed magnetization measurements on single crystals of La2-xSrxNiO4+δ using a SQUID magnetometer (Quantum Design). The single crystals were grown by the floating-zone technique from high purity oxides. These crystals have a typical size of $`5\times 5\times 2`$mm. The oxygen content was determined by thermogravimetric analysis.

Figure 1 shows a set of typical results, obtained from a sample with $`x`$ = 0.275 with a measuring field of 500 Oe applied parallel to the $`ab`$ plane. The charge and spin ordering temperatures are indicated. A spin glass phase at low temperature ($`T_{\mathrm{SG1}}`$ $``$ 40 K) is signalled by a clear divergence of the zero-field-cooled (ZFC) and field-cooled (FC) magnetization. However, glassy behaviour is seen to extend to much higher temperatures: a smaller ZFC/FC splitting only vanishes at a temperature $`T_{\mathrm{SG2}}`$ between $`T_{\mathrm{SO}}`$ and $`T_{\mathrm{CO}}`$. In the case of $`x`$ = 0.5, where $`T_{\mathrm{SO}}`$ $``$ 90 K and $`T_{\mathrm{CO}}`$ $``$ 480 K, the ZFC and FC curves did not close up until well above TSO. Hence the $`T_{\mathrm{SG2}}`$ feature appears to be correlated with charge-ordering.

In the spin glass phase of LSNO we observed all the materials to have an effective ‘memory’ of their temperature-field history in the $`ab`$ plane. We observed this by cooling the sample in a field of 500 Oe to $`T_0`$ ($`<`$ $`T_{\mathrm{SG1}}`$), removing the field, cooling to 2 K, and then measuring in zero field while warming. Apart from the $`x`$ = 0.333 sample, we observe a stable ($`>`$ 1 hr) induced magnetic signal that decreased in size above $`T_0`$, and finally levels off to a constant value at $`T_{\mathrm{SG1}}`$, see figure 2. With $`x`$ = 0.333, the signal is small at low temperatures, but rises sharply just below $`T_{\mathrm{SR}}`$ 50 K, corresponding to a known spin reorientation. The $`x`$ = 0.5 material also has a spin reorientation, but no suppression of this FC-induced signal was observed in this material, although a change in the slope can be seen at $`T_{\mathrm{SR}}`$ 57 K, which is $``$ $`T_{\mathrm{SG1}}`$ in this material. Again this shows how the commensurability of the 0.333 and 0.5 doped materials cause them to behave differently from other doping levels.

Our results further add to the knowledge of the glassy behaviour associated with charge-stripe ordering in LSNO. The existence of two apparently different glassy regimes, as well as other unusual field-temperature hysteretic effects, shows that the glassy properties of stripe phases are quite different to those observed in many other spin-glass materials. Further work needs to be carried out to determine the nature of these effect in fields parallel to $`c`$.


text:
# A Comment on Liu and Yau’s positive quasi-local mass

## Abstract

With the aid of a simple family of examples, we show that the quasi-local mass defined by Kijowski K  and Liu and Yau LY  and shown by Liu and Yau to be positive, may be strictly positive for space-like, topologically spherical 2-surfaces in flat space-time.

In a recent letter, LY , Liu and Yau propose a definition of quasi-local mass for any space-like, topological 2-sphere with positive intrinsic (or Gauss) curvature. In fact, their expression is precisely the ‘quasi-local free energy’ of Kijowski K . However, Liu and Yau are able to prove positivity of this mass by exploiting a result of Shi and Tam, ST , which proves positivity of the ADM mass on space-like 3-surfaces with an inner boundary. This is an impressive result.

As Liu and Yau note, there have been many attempts to define a quasi-local mass or energy associated to a space-like 2-surface and there are certain natural questions to ask of any new definition. One possible set of such questions was published by Christodoulou and Yau, CY , as properties which a definition *must* have. There is no general consensus as to the necessity of all the properties demanded by Christodoulou and Yau, but the first of them, that the definition should give zero for any 2-surface in flat space-time, has wide support. It is therefore worth noting, and it is the purpose of this Comment to note, that the definition of Kijowski, Liu and Yau does not have this property: there are space-like, topological 2-spheres in flat space for which their mass is strictly positive. In fact there is a simple class of examples for which the whole construction is easy to see and we shall present these below.

The definition of mass given by Kijowski, Liu and Yau belongs to the class of definitions initiated by Brown and York BY  for a 2-surface $`\mathrm{\Sigma }`$ of the kind considered. A definition in this class considers a quantity $`Q`$ obtained by integrating over $`\mathrm{\Sigma }`$ an expression constructed from the *data* of $`\mathrm{\Sigma }`$, by which we mean the first and second fundamental forms and the connection on the normal bundle. To complete the definition, one then subtracts a quantity $`Q_0`$ from $`Q`$ which is intended to be the value ‘in flat space-time’ of $`Q`$. Difficulties arise with saying precisely what the subtraction should be, as a 2-surface in curved space-time cannot in general be embedded in flat space-time with the same data.

Kijowski, Liu and Yau restrict consideration to 2-surfaces $`\mathrm{\Sigma }`$ with positive intrinsic curvature (and subject to a second condition, given below). By Weyl’s embedding theorem, such a $`\mathrm{\Sigma }`$ can be isometrically embedded in flat (Euclidean) 3-space $`E^3`$ with positive-definite extrinsic curvature tensor. The embedding is unique up to isometry of $`E^3`$. The flat $`E^3`$ can be thought of as a constant-time hyperplane in flat (Minkowski) space-time, and it is then this embedding which is used to define the subtraction mentioned above. Specifically, the Kijowski-Liu-Yau definition of quasi-local energy (equation (105) of K  and (3) of LY ) is

$$E_{KLY}=\frac{1}{8\pi G}_\mathrm{\Sigma }(k_0k)$$
(1)
where $`G`$ is Newton’s gravitational constant, $`k_0`$ is the trace of the extrinsic curvature of $`\mathrm{\Sigma }`$ as embedded in $`E^3`$ and $`k`$ is given in terms of the Newman-Penrose spin-coefficients $`\rho `$ and $`\mu `$, (see NP  or PR ), as

$$k=\sqrt{8\rho \mu }.$$
(2)
Here, as is standard, $`\rho `$ is minus half the expansion of the outgoing future null normal to $`\mathrm{\Sigma }`$, and $`\mu `$ is half the expansion of the ingoing future null normal, suitably normalised. Kijowski and Liu and Yau require the product $`\rho \mu `$ to be positive for their definition, which is equivalent to the condition that the mean-curvature vector of $`\mathrm{\Sigma }`$ be time-like. This is the second condition on $`\mathrm{\Sigma }`$ whose necessity was noted above.

Clearly, equation (1) will give $`E_{KLY}=0`$ for any $`\mathrm{\Sigma }`$ which lies in a space-like hyperplane in flat space-time. However, for a $`\mathrm{\Sigma }`$ in flat space-time, with positive intrinsic curvature and time-like mean curvature vector but which does *not* lie in a space-like hyperplane, there is no reason to think that $`E_{KLY}`$ should vanish, and in fact it need not. Our purpose now is to describe a simple class of $`\mathrm{\Sigma }`$ with these properties and non-zero $`E_{KLY}`$.

The idea is to consider a 2-surface which is a cross-section of the light-cone of the origin in flat space-time. We introduce spherical polar coordinates $`(t,r,\theta ,\varphi )`$ based at the origin so that the Minkowski metric is

$$ds^2=dt^2dr^2r^2(d\theta ^2+\mathrm{sin}^2\theta d\varphi ^2).$$

The future light-cone $`N`$ of the origin is given by $`t=r>0`$ and we may define a topological 2-sphere $`\mathrm{\Sigma }`$ lying on $`N`$ by an equation of the form

$$t=r=F(\theta ,\varphi )$$
(3)
for a positive, smooth function $`F`$. With a natural choice of normals to $`\mathrm{\Sigma }`$, the relevant spin-coefficients are given by

$`\rho `$ $`=`$ $`{\displaystyle \frac{1}{\sqrt{2}F}}`$ (4)
$`\mu `$ $`=`$ $`{\displaystyle \frac{1}{\sqrt{2}F}}(1\mathrm{\Delta }\mathrm{log}F)`$ (5)
where $`\mathrm{\Delta }`$ is the Laplacian on the unit sphere. The spin-coefficient $`\sigma `$ is zero (as $`\mathrm{\Sigma }`$ lies on a light-cone and these are shear-free in flat space-time) so that the intrinsic curvature $`K`$ of $`\mathrm{\Sigma }`$, calculated for example from the formula (4.14.20) in PR , is given by

$$K=2\rho \mu .$$
(6)
(Note the relation of $`K`$ to $`k`$ in equation (2): $`k=2\sqrt{K}`$).

Thus $`\mathrm{\Sigma }`$ has positive intrinsic curvature and time-like mean curvature vector iff $`\mathrm{\Delta }\mathrm{log}F<1`$, which is easy to arrange. Suppose this holds, then following the prescription of Kijowski, Liu and Yau, we embed $`\mathrm{\Sigma }`$ into $`E^3`$, where it will define a convex topological 2-sphere $`\mathrm{\Sigma }_0`$ with mean curvature say $`H`$ and intrinsic curvature $`K`$ as above. (Conversely, we can obtain a $`\mathrm{\Sigma }`$ subject to the conditions considered by starting from such a $`\mathrm{\Sigma }_0`$.) We calculate $`E_{KLY}`$ using equations (1), (2) and (6) above to find the expression

$$E_{KLY}=\frac{1}{8\pi G}_\mathrm{\Sigma }(2H2\sqrt{K}).$$
(7)
At this stage, we are considering the expression (7) for an arbitrary convex topological 2-sphere $`\mathrm{\Sigma }_0`$ in $`E^3`$, and clearly it need not vanish. If we introduce the usual principal curvatures $`\lambda _1`$ and $`\lambda _2`$, both of which are positive for a convex surface, then (7) becomes

$$E_{KLY}=\frac{1}{8\pi G}_\mathrm{\Sigma }(\sqrt{\lambda }_1\sqrt{\lambda }_2)^2.$$

This vanishes for a round 2-sphere (as expected, since in this case the cross-section of $`N`$ in fact lies in a hyperplane) but is otherwise positive: the Kijowski-Liu-Yau definition can be strictly positive for space-like, topological 2-spheres in flat space-time.

Kijowski has another definition for the quasi-local energy (equation (97) of K ), which is also positive for the 2-surfaces presented here. The Brown-York energy with the flat space reference BY  and the two light cone references considered in BLY  and in L  are also non-zero in general.

This work was initiated at the Erwin Schrödinger Institut, Vienna and we gratefully acknowledge the hospitality of the Institut. LBSz was partially supported by the Hungarian Scientific Reseach Fund grants OTKA T030374 and T042531.


text:
# Monte Carlo Hamiltonian: Inverse PotentialLXQ is supported by the Key Project of National Science Foundation (10235040), National and Guangdong Ministries of Education, and Foundation of Zhongshan University Advanced Research Center. HK is supported by by NSERC Canada.

## 1 Introduction

There are two standard approaches in quantum theory: Hamiltonian and Lagrangian formulations. A comparison is given in Tab.1. The Lagrangian formulation is very suitable for applying the Monte Carlo (MC) method to systems with many degrees of freedom, and in the last two decades, it has been widely applied to lattice gauge theory. In the standard Lagrangian MC method, however, it is extremely difficult to compute the spectrum and wave function beyond the ground state.

Wave functions in conjunction with the energy spectrum contain more physical information than the energy spectrum alone. Although lattice QCD simulations in the Lagrangian formulation give good estimates of the hadron masses, one is yet far from a comprehensive understanding of hadrons. Let us take as example a new type of hardrons made of gluons, the so-called glueballs. Lattice QCD calculations  predict the mass of the lightest glueball with quantum number $`J^{PC}=0^{++}`$, to be $`1650\pm 100MeV`$. Experimentally, there are at least two candidates: $`f_0(1500)`$ and $`f_J(1710)`$. The investigation of the glueball production and decays can certainly provide additional important information for experimental determination of a glueball. Therefore, it is important to be able to compute the glueball wave function.

A natural question is whether in Lagrangian MC simulations one can construct an effective Hamiltonian? We have recently proposed a new approach (named Monte Carlo Hamiltonian method) to investigate this problem. We start out from the action of the theory. We compute the transition matrix for all transitions using MC with importance sampling, where the states are taken from a basis in Hilbert space. As a result, we find an effective Hamiltonian, i.e. its spectrum and eigen states. A lot of models in quantum mechanics (QM) have been used to test the method. This method has also been applied to scalar field theories.

Although MC with importance sampling has been very successful for QM with many local potentials, it is very difficult for QM with inverse potentials, due to the singularity. In this paper, we propose effective potential and extrapolation method to solve the problem. The hydrogen system is used as an example.

The rest of the paper is organized as follows. In Sect.2 and Sect. 3, the basic ideas of MC Hamiltonian are reviewed. In Sect. 4, we describe a method to analyze the errors of the spectrum and wave functions. In Sect. 5, a method to investigate the inverse potential is presented. The numerical results for the hydrogen system are given in Sect. 6 and summarized in Sect. 7.

## 2 Effective Hamiltonian

Let us discuss the construction of the effective Hamiltonian in several steps . First, consider in quantum mechanics in 1-dim the motion of a single particle of mass $`m`$ under the influence of a local potential $`V(x)`$. Its classical action is given by

$`S={\displaystyle 𝑑t\left(\frac{m}{2}\dot{x}^2V(x)\right)}.`$ (1)
Given the classical action, one can determine Q.M. transition amplitudes. Like in Lagrangian lattice field theory, we use imaginary time in what follows. We consider the transition amplitude for some finite time $`T`$ ($`t_{in}=0`$, $`t_{fi}=T`$) and for all combinations of positions $`x_i,x_j`$. Here $`x_i`$, $`x_j`$ run over a finite discrete set of points $`\{x_1,\mathrm{},x_N\}`$ located on the real axis. Suppose these points are equidistantly distributed (spacing $`\mathrm{\Delta }x`$) over some interval $`[L,+L]`$. The transition amplitudes are given by the (Euclidean) path integral,

$`M_{ij}(T)={\displaystyle [dx]\mathrm{exp}[S_E[x]/\mathrm{}]}|_{x_j,0}^{x_i,T},`$ (2)
where $`S_E=𝑑t\left(m\dot{x}^2/2+V(x)\right)`$ denotes the Euclidean action. Suppose for the moment that those transition amplitudes were known. From that one can construct an approximate, i.e. effective Hamiltonian. Note that the matrix $`M(T)=[M_{ij}(T)]_{N\times N}`$ is a real, positive and Hermitian matrix. It can be factorized into a unitary matrix $`U`$ and a real diagonal matrix $`D(T)`$,

$`M(T)=U^{}D(T)U.`$ (3)
Because the matrix $`M(T)`$ can be expressed in terms of the full Hamiltonian $`H`$ by

$`M_{ij}(T)=x_i|\mathrm{exp}(HT/\mathrm{})|x_j,`$ (4)
the matices $`U`$ and $`D`$ have the following meaning,

$`U_{ik}^{}=<x_i|E_k^{eff}>`$
$`D_k(T)=\mathrm{exp}(E_k^{eff}T/\mathrm{}),`$ (5)
i.e., the $`kth`$ eigenvector $`|E_k^{eff}>`$ of the effective Hamiltonian $`H_{eff}`$ can be identified with the $`kth`$ column of matrix $`U^{}`$ and the energy eigenvalues $`E_k^{eff}`$ of $`H_{eff}`$ can be identified with the logarithm of the diagonal matrix elements of $`D(T)`$. This yields an effective Hamiltonian,

$`H_{eff}={\displaystyle \underset{k=1}{\overset{N}{}}}|E_k^{eff}>E_k^{eff}<E_k^{eff}|.`$ (6)
Note that in the above we have been mathematically a bit sloppy. The states $`|x_i`$ are not Hilbert states. We have to replace $`|x_i`$ by some “localized” Hilbert state. This can be done by introducing box states. We associate to each $`x_i`$ some box state $`b_i`$, defined by

$`b_i(x)=\{\begin{array}{c}1/\sqrt{\mathrm{\Delta }x_i}\text{if}x_i<xx_{i+1}\hfill \\ 0\text{else}\hfill \end{array}`$ (9)
where $`\mathrm{\Delta }x_i=x_{i+1}x_i`$. When we use an equidistant distribution of $`x_i`$, i.e. $`\mathrm{\Delta }x_i=\mathrm{\Delta }x`$, we refer to the basis of box states as the regular basis.

## 3 Matrix elements

We compute the matrix element $`M_{ij}(T)`$ directly from the action via Monte Carlo with importance sampling. This is done by writing each transition matrix element as a ratio of two path integrals. This is done by splitting the action into a non-interacting part and an interacting part,

$`S_E=S_0+S_V.`$ (10)
This allows to express the transition amplitude by

$`M_{ij}(T)=M_{ij}^{(0)}(T){\displaystyle \frac{_{x_i}^{x_{i+1}}𝑑y_{x_j}^{x_{j+1}}𝑑z[dx]\mathrm{exp}[S_V[x]/\mathrm{}]\mathrm{exp}[S_0[x]/\mathrm{}]|_{z,0}^{y,T}}{_{x_i}^{x_{i+1}}𝑑y_{x_j}^{x_{j+1}}𝑑z[dx]\mathrm{exp}[S_0[x]/\mathrm{}]|_{z,0}^{y,T}}},`$ (11)
Here $`\mathrm{exp}(S_0/\mathrm{})`$ is the weight factor and $`\mathrm{exp}(S_V/\mathrm{})`$ is the observable. $`M_{ij}^{(0)}(T)`$ stands for the transition amplitude of the noninteracting system, which is (almost) known analytically. For details see ref.. Carrying out these steps allows to construct an effective Hamiltonian, which has turned out to reproduce well low energy physics of a lot of quantum systems .

## 4 Error analysis

From errors of the matrix elements $`\mathrm{\Delta }M`$ in Monte Carlo simulations, one can obtain the errors of the eigen value $`E_n`$ and wave function $`\psi _n`$ of the effective Hamiltonian. Suppose $`H`$ is the Hamiltonian of the theory, $`H^{}`$ is a perturbation term induced by error in the simulation, then we have the following equation for the transition matrix element

$`\mathrm{exp}\left({\displaystyle \frac{(H+H^{})T}{\mathrm{}}}\right)\mathrm{exp}\left({\displaystyle \frac{HT}{\mathrm{}}}\right){\displaystyle \frac{T}{\mathrm{}}}\mathrm{exp}\left({\displaystyle \frac{HT}{\mathrm{}}}\right)H^{^{}},`$ (12)
which implies

$`\mathrm{\Delta }M`$ $`=`$ $`\mathrm{exp}\left({\displaystyle \frac{(H+H^{})T}{\mathrm{}}}\right)\mathrm{exp}\left({\displaystyle \frac{HT}{\mathrm{}}}\right)`$ (13)
$``$ $`{\displaystyle \frac{T}{\mathrm{}}}\mathrm{exp}\left({\displaystyle \frac{HT}{\mathrm{}}}\right)H^{^{}}`$
or

$`H^{}{\displaystyle \frac{\mathrm{}}{T}}M^1\mathrm{\Delta }M.`$ (14)
According to perturbation theory, the first order correction to the eigen value and wave function is

$`\mathrm{\Delta }E_n`$ $`=`$ $`H_{nn}^{}={\displaystyle \frac{\mathrm{}}{T\mathrm{exp}(E_nT/\mathrm{})}}{\displaystyle 𝑑x\psi _n^{}\mathrm{\Delta }M\psi _n}`$
$`\psi _n^{}`$ $`=`$ $`{\displaystyle \underset{n^{}n}{}}{\displaystyle \frac{H_{n^{}n}^{}}{E_nE_n^{}}}\psi _n^{}`$ (15)
where

$`H_{n^{}n}^{}={\displaystyle 𝑑x\psi _n^{}^{}H^{}\psi _n}.`$ (16)
Eq. (15) gives an estimate of the wave function.

## 5 Inverse potential: the hydrogen atom

The Schrödinger equation of a hydrogen is

$`{\displaystyle \frac{\mathrm{}^2}{2m}}^2\mathrm{\Psi }(r,\theta ,\phi )+V(r)\mathrm{\Psi }(r,\theta ,\phi )=E\mathrm{\Psi }(r,\theta ,\phi ),`$ (17)
where

$`V(r)={\displaystyle \frac{e}{r}}.`$ (18)
Because of the spherical symmetry, the wave function can be factorized as

$`\mathrm{\Psi }(r,\theta ,\phi )=\psi (r)Y(\theta ,\phi ),`$ (19)
and the radial wave function satisfies

$`{\displaystyle \frac{\mathrm{}^2}{2m}}\left[r^2{\displaystyle \frac{d}{dr}}\left(r^2{\displaystyle \frac{d\psi (r)}{dr}}\right)\right]+\left[V(r)+{\displaystyle \frac{l\left(l+1\right)\mathrm{}^2}{2mr^2}}\right]\psi (r)=E\psi .`$ (20)
Defining a function $`u(r)`$ by

$`u(r)=r\psi (r),`$ (21)
and considering the case of angular-momentum quantum number zero ($`l=0`$), one obtains

$`{\displaystyle \frac{\mathrm{}^2}{2m}}{\displaystyle \frac{d^2u}{dr^2}}+V(r)u=Eu`$ (22)
which reduces to a one dimensional QM problem. This system has the following analytic result for the energy

$`E_n={\displaystyle \frac{1}{2(n+1)^2}},`$ (23)
where $`n=0,1,\mathrm{}`$ is the principal quantum number and $`m=1`$, $`e=1`$, $`\mathrm{}=1`$ have been chosen. The ground state and first excited state radial wave functions are

$`\psi _0(r)`$ $`=`$ $`2\mathrm{exp}(r),`$
$`\psi _1(r)`$ $`=`$ $`{\displaystyle \frac{1}{\sqrt{2}}}\left(2r\right)\mathrm{exp}(r/2).`$ (24)
Our purpose is to investigate the 1-d system NOT by solving Eq. (22), but by MC Hamiltonian method. Unfortunately, due to the divergence of $`V(r)`$ at $`r=0`$, it is not convenient for MC simulations.

To solve the problem, we replace $`V(r)`$ by an effective potential with cut-off parameter $`R`$

$`V_R(r)={\displaystyle \frac{\mathrm{exp}(2r/R)1}{\mathrm{exp}(2r/R)+1}}V(r).`$ (25)
$`V_R(r)`$ approaches to $`V(r)`$ when $`R0`$ and $`V_R(r)`$ is analytic for any value of finite $`R`$, which will be used in numerical simulations.

## 6 Numerical results

The coordinates for the box state (see Eq. (9)) are chosen to be

$`r_i=idr,i=1,2,\mathrm{},N.`$ (26)
The simulation parameters are $`m=1`$, $`e=1`$, $`\mathrm{}=1`$, $`T=0.85`$, $`dr=0.99`$ and $`N=100`$. Using the Metropolis algorithm and method described in Sect. 3, we obtain the matrix elements $`M_{n^{}n}`$ with potential $`V_R(r)`$ for some non-zero $`R`$. Then we compute the eigenvalues and eigenvectors using the method described in Sect. 2 and analyze their errors using the method described in Sect. 4.

Fig. 1 plots the ground state energy of the hydrogen system with effective potential $`V_R(r)`$ at $`R=`$0.3, 0.4, 0.5, 0.6, 0.7 and 0.8. Between initial and final $`r_i`$, 600 paths are used in MC simulations. We use the least square method to extrapolate the data to the $`R=0`$ limit. The result agrees with the analytic one within large error bar. Fig. 2 plots the first excited state energy. The agreement is greatly improved if more paths (1000) are used in MC simulations. This is shown in Fig. 3 and Fig. 4.

Fig. 5 plots the ground state wave function of the hydrogen system extrapolated to $`R=0`$. Between initial and final $`r_i`$, 1000 paths are used in MC simulations. Fig. 6 shows the first excited state wave function. They are consistent with the analytic ones.

## 7 Summary

In the preceding sections, we have extended the effective Hamiltonian method to QM with inverse potentials, and taken the hydrogen system as an example. The results are encouraging. We believe that the application of the algorithm to more complicated systems will be very interesting. It will allow a non-perturbative investigation of physics beyond the ground state.


text:
# SHERPA 1.𝜶, a proof-of-concept version

## 1 Introduction

To a large amount, modern particle physics centres around accelerator experiments, where high-energetic particles are brought to collision. With rising energies, these interactions become more and more violent, leading to an increasing number of particles being produced. To confront the resulting experimental data with theoretical models, a systematic understanding of such multi-particle production processes is of paramount importance. A full, quantum-mechanically correct, treatment is, at the moment, out of reach. There are two reasons for this:

First of all, there only is a limited understanding of the non-perturbative phase of QCD, or, in other words, of how colourless hadrons are built from the coloured quarks and gluons. This is especially true for phenomena such as hadronisation or for questions related to the impact of the partonic substructure of the colliding hadrons on the pattern of multiple interactions. In all such cases, phenomenological models for the transition from hadrons to partons or vice versa have to be applied with parameters to be fitted. This clearly puts a constraint on a conceptual understanding of high-energy particle production processes. On the other hand, even considering the, in principle, well-understood perturbative phase of scattering processes alone, there are limits on our technical abilities to calculate all amplitudes that contribute to a given process. This is due to the fact that even at the tree-level the number of Feynman diagrams grows factorially with the number of particles involved. Moreover, at higher orders of the perturbative evolution new difficulties arise, which are connected for instance with the evaluation of multi-leg loop integrals.

This failure necessitates other, approximate solutions, such as simulation programs. These event generators decompose the full scattering process into a sequence of different stages, which are usually characterised by different energy scales. The past and current success of event generators, like Pythia  or Herwig , in describing a full wealth of various data justifies this decomposition intrinsic to all such programs. As a by-product, the decomposition of events into distinguishable, more or less independent phases opens a path to test the underlying assumptions on the dynamics of particle interactions at the corresponding scales. These assumptions, in turn, can be modified and new models can be included on all scales. This property turns event generators into the perfect tool to bridge the gap between experimental data and theoretical predictions. It renders them indispensable for the analyses and planning of current and future experiments.

To meet the new challenges posed by the new experiments, for instance Tevatron at Fermilab and especially LHC at CERN, the traditional event generators Pythia and Herwig, so far programmed in Fortran, are currently being re-written in the modern, object-oriented programming language C++. Their new versions will be called Pythia7  and Herwig++ , respectively. The decision to re-write them from scratch is based on two reasons:

First, new features and models concerning the simulation of particle physics at the shifting energy frontier need to be included. In fact this still is an on-going issue also for the Fortran versions (see for instance ).

Furthermore, and maybe more importantly, there is a wide-spread belief that the old Fortran codes cannot easily be maintained or extended. On top of that, the software paradigm of the new experiments has already shifted to object-orientation, more specifically, to C++ as programming language. On the other hand, by the virtue of being decomposed into nearly independent phases, the simulation of high-energy particle reactions lends itself to modularisation and, thus, to an object-oriented programming style. In this respect it is also natural to further disentangle management and physics issues in event generation. In fact, both Pythia7 and Herwig++ will fully rely on the same management structure, called ThePEG . It includes items such as the event record, mathematical functions, management functionalities, etc.. Using this common event-generation framework, Pythia7 and Herwig++ will just provide their respective, different modules for physics simulation, for instance the implementations of their hadronisation models.

In addition to these two re-writes of their older, Fortran-based counterparts, in the past few years a new event generator, called SHERPA, acronym for Simulation for High-Energy Reactions of PArticles, has been developed independently. From the beginning, it entirely has been written in C++, mainly due to the same reasons already named above. A number of paradigms have been the guiding principles in the construction of this code:

1. Modularity:
SHERPA only provides the framework for event generation. The physics issues related to the various phases of event generation are handled by specific, physics-oriented modules. These modules, however, rely on a number of service modules that incorporate basic organisational, mathematical or physics tools, or information concerning the physics environment.
2. Separation of interface and implementation:
Within SHERPA, the specific physics modules are interfaced through corresponding (handler) classes, which are sufficiently abstract to support an easy inclusion of other modules with similar tasks.
3. Bottom-to-top approach:
Before the interfaces (abstract handlers) are implemented, the corresponding physics module has been programmed and tested. This is especially true for modules like AMEGIC++ , providing a full-fledged matrix-element generator for the evaluation of multi-particle production cross sections, or APACIC++ , hosting a parton shower module. In general, these modules can be used as stand-alone codes. They also can be implemented into other event-generation frameworks with minor modifications only, as long as some of the underlying mathematical and physics tools are supplemented as well.

The goal of this publication is to give a brief status report of SHERPA’s first $`\alpha `$-version. It already incorporates enough functionality to make SHERPA a useful tool for a number of physics applications.

The outline of this paper is as follows: in Sec. 2 the overall generation framework is briefly introduced. This basically amounts to a discussion of how the framework and its physics modules are initialised, and how these modules are handed over to the actual event generation. Then, in the next two sections, Secs. 3 and 4, general tools for event generation, including for instance the event record, are presented as well as those modules that specify the physics environment (such as the physics model, beam spectra, or parton distribution functions), in which the simulation is performed. In the following, the implementation of some of the event phases reflecting different physics features will be briefly highlighted. The discussion is commenced with describing the inclusion of hard matrix elements for jet production etc. (Sec. 5) and for heavy-particle decays such as, e.g., top-quark decays, (Sec. 6) into SHERPA. Matrix elements are also needed for the simulation of multiple hard parton interactions in hadronic collisions. Hence, in Sec. 7 a brief outlook will be given on how SHERPA will describe such phenomena. In all cases mentioned above, the matrix elements may give rise to configurations of jets to be fragmented by the subsequent parton shower. A cornerstone of SHERPA is the implementation of an algorithm, which merges matrix elements and parton showers respecting the next-to leading logarithmic accuracy of the parton shower (for details on this algorithm, see ). In Sec. 8, questions related to the inclusion of this algorithm and the interplay with the parton shower inside the SHERPA framework are discussed. The quick tour through the event phases will be finished in Sec. 9 with a discussion of issues related to soft QCD, e.g. hadronisation, beam jets, etc.. Finally, in Sec. 10, conclusions will be drawn and a further outlook will be given.

## 2 Overall event-generation framework

In SHERPA, the various tasks related to event generation are encapsulated in a number of specific modules. From a structural point of view, the set-up of the event-generation framework condenses into the problem to define the rules for the interplay of these modules and to implement them. The flexibility to do so is increased by a separation of the interfaces defining this interplay from the specific modules – the implementations of physics tasks111 Of course, this abstraction is to some extent limited by a kind of linguistic problem: in the implementation of the physics tasks, a choice has to be made on the terms in which the tasks are formulated. As a simple example consider four-momenta, clearly a basic ingredient of event generators. In ThePEG, the choice has been made to represent them as five-vectors, where the fifth component denotes the mass related to the four-momentum; in contrast, in SHERPA the representation is in terms of plain four-vectors. To use ThePEG modules within SHERPA requires a translation, which in SHERPA would be performed through the interface classes. The objects defining the terms in which physics tasks are implemented inside SHERPA are accumulated in a namespace ATOOLS, cf. Sec. 3. Clearly, all other modules rely on these definitions.. How this is realized within SHERPA can be exemplified by the hard matrix elements:

There are two implementations, which can be used to generate hard partonic subprocesses. One of them is restricted to a list of analytically known $`22`$ processes, the other one is the multipurpose parton-level generator AMEGIC++. However different they are, in the framework of event generation they have to calculate total cross sections for the hard subprocesses and they must provide single weighted or unweighted events. In SHERPA, these functionalities of both modules are accessible through an interface, the Matrix\_Element\_Handler. It naturally lives up to the intrinsic differences in these physics implementations. Without knowing any details about the realization of hard matrix elements in the modules, they can be plugged anywhere into the event-generation framework by means of this abstract handler class. To add another module concerned with hard partonic subprocesses, on the level of SHERPA one would just have to extend the corresponding methods of the Matrix\_Element\_Handler accordingly. This reflects a typical object-oriented design principle.

In general, such abstract handler classes encapsulate the specific physics implementations and are used to interface them with each other. Further examples that have been implemented so far include the Beam\_Spectra\_Handler, the ISR\_Handler, the Hard\_Decay\_Handler, the Shower\_Handler, the Beam\_Remnant\_Handler and the Fragmentation\_Handler. They will be described in the forthcoming sections.

In many cases the underlying physics modules will require some initialisation before they can be used during event generation. Again, this can be exemplified by the hard matrix elements. In this case the initialisation basically consists of tasks like the set-up of matrix elements and phase-space integrators, and of the evaluation of total cross sections. They define the relative contributions of individual sub-processes in the overall composition of the hard process part inside the events. It is clear that such tasks have to be performed in an initialisation phase of an event-generation run. During this phase, SHERPA initialises the various physics modules selected by the user through the abstract handlers responsible for them. The specific set-up of a selected module will depend on external, run-specific parameters, which are read-in from corresponding data files and managed by the same handler class. The initialisation sequence of these handlers and their physics modules is organised by a SHERPA-internal Initialization\_Handler, which also owns the pointers to the handlers. To add new handlers for completely new physics features, therefore, necessitates to modify and extend this Initialization\_Handler.

Having initialised the interfaces to the physics modules, the SHERPA framework is ready for event generation. As already stated before, the individual events are decomposed into separate phases. This decomposition is reflected by SHERPA’s program structure in the following way: an Event\_Handler object manages the generation of one single event by having a list of various Event\_Phase\_Handlers acting on the expanding event record. This process of event generation is formulated in terms of particles connecting generalised vertices, coined blobs. These Blobs in turn reflect the space-time structure of the event, each of them has a list of incoming and outgoing particles. In other words, the blobs are the nodes, the particles are the connecting lines of a network. For a pictorial example, confronting a simple hadron–hadron event with its representation through Blobs, cf. Fig. 1.

An event thus can be represented as a list of Blobs, which in turn forms SHERPA’s event record. The Event\_Phase\_Handlers act on this list, by either modifying the Blobs themselves or by adding new Blobs or by subtracting unwanted ones. For event generation, the list of Event\_Phase\_Handlers is tried on the list of Blobs until no more action is possible, i.e. until none of the individual Event\_Phase\_Handlers finds an active Blob it can deal with. To illustrate this, consider the following simple example:

* First of all, a yet unspecified blob of the type “Signal Process” is added to the so far empty Blob list. Iterating with the list of Event\_Phase\_Handlers the Signal\_Processes phase deals with the single unspecified active Blob, inserting a number of incoming and outgoing partons through the Matrix\_Element\_Handler.
* In the next iteration of the Event\_Phase\_Handlers, the Jet\_Evolution phase steps over this Blob and adds parton showers to it. To this end, some “ME PS Interface” Blobs are added as well as some Blobs for the initial- and final-state parton shower, signified by the types “IS Shower” and “FS Shower”, respectively. Assuming that an $`e^+e^{}`$ annihilation into hadrons is simulated, the “IS Shower” Blobs have one incoming and one outgoing electron each, and, maybe, some outgoing photons as well. The “Signal Process” as well as the “ME PS Interface” Blobs are switched to passive by this phase.
* The Hadronisation phase selects out the shower Blobs for the transition of partons into hadrons. First the Beam\_Remnant\_Handler has to fill “Beam Remnant” and “Bunch” Blobs. In the toy example, both, however, have a simple structure with one incoming and one outgoing electron each. Now, the Fragmentation\_Handler comes into play, adding more blobs of the type “Fragmentation” with a number of incoming partons and a number of outgoing primary hadrons. All Blobs apart from the “Fragmentation” ones would be switched to passive now, leaving the outgoing primary hadrons to be decayed. These decays would be represented by more Blobs of the type “Hadron Decay”.

The structure elucidated above allows for nearly arbitrary mixtures in the composition of an event. For example, through the action of the Jet\_Evolution phase the parton shower could in principle alternate with a sequence of hard decays on the parton level, or it could even be invoked in the decay of a heavy hadron.

In Fig. 2 the Event\_Phase\_Handlers implemented so far and their connections to various interfaces are exhibited.

## 3 Tools for event generation

In SHERPA, the basic infrastructure for event generation, which is used by other modules, is centralised in a separate package, called ATOOLS. It contains management, mathematics, and physics tools.

The organisational tools include, among others, classes to read-in input data, and to provide parameters and objects that must be globally accessible. During the initialisation of the SHERPA environment this data-container class is instantiated as a global object, which is filled and accessed by the other modules in due course. Therefore, if a potential user wants to include more objects that are needed in very separate corners of the total framework, he or she would have to include these objects into this class Run\_Parameters. Of course, the corresponding access methods have to be provided there as well. SHERPA offers the possibility to specify a large amount of parameters for a run without recompiling. To enhance the transparency of the read-in procedure and to contribute to its intuitive understanding, the variables might be contained in different, user-specified data files in the following fashion:

```
  KEYWORD = Value .

```

Within the code, default values can be given for the parameters connected to the keywords. An example defining, e.g. the physics model, and declaring the Standard Model as the default choice, reads:

```
  Data_Read _dataread(path,file);
  std::string model = _dataread.GetValue("MODEL",std::string("SM"));

```

In its instantiation, the \_dataread-object is given the path and the file name for the read-in procedure.

A second group provides mathematical service classes, including:

* a representation of three- and four-vectors;
* a class for real or complex matrices;
* a representation of Lorentz-transformations (boosts and rotations);
* abstract definitions of functions or grids which can be integrated or inverted;
* a class for simple histograms and operations on them;
* the random number generator.

This group of objects defines the mathematical terms in which SHERPA generates events.

The basic physics terms are also part of the ATOOLS package and cover a wide range of applications. In the following, some of the corresponding basic classes will be briefly described:

* Particles are described by some, in principle, unchangeable characteristics: their quantum numbers, their mass and width, etc.. All these properties are contained in a Flavour object. Within SHERPA, also pseudo-flavours, for instance “jet”, are available. Hence, a Flavour object might serve as a container for other Flavours. In SHERPA the particles and their properties are collected in two data files, Particle.dat and Hadron.dat. A typical line in these files looks like:

```
      kf  Mass  Width  3*e  Y  SU(3)  2*Spin  maj  on  stbl  m_on  Name
      1   .01   .0     -1   -1   1      1      0   1    1     0    d

```
Apart from the mass, width and spin, the electrical charge, the third component of the weak iso-spin, and the ability to participate in strong interactions are defined. In addition, for fermions, the user should provide information whether a specific Flavour describes Majorana particles or not. Also, information has to be provided, whether individual particles should be included at all, whether they are stable or not, and whether their mass should be taken into account in matrix-element calculations222It should be mentioned here that this mass enters in the phase space and in the propagators. For the Yukawa couplings these masses, if switched on, serve as default value, but can be overwritten during the initialisation of the physics models.. Finally, the particles’ names should be defined as well in a form that will show up in the event record.
* In some cases, the user might wish to have, e.g., the matrix-element generator(s) to calculate the width of a Flavour, thus overwriting the one given in Particle.dat. To this end, another data file, by default called Decays.dat, might be read-in. Then, for the corresponding particles, decay tables are constructed and evaluated. They are implemented as Decay\_Table objects.
* The particles, which finally show up in the generated event, are represented through a class Particle. In addition to the data objects specifying its properties, the Particles are characterised by their four-momenta, by the vertices (Blobs) in which they are created or end, and by the flow of quantum numbers associated with them, such as colour.

In addition to the classes outlined above, the ATOOLS package includes classes which define some physics observables or which can be used to select events. These Selector classes are also needed for the integration over the phase space of the final state in hard subprocesses. One of them is providing a definition of jets according to the $`k_{}`$\- (or Durham-) algorithm  in various collision types. It is of special importance for the SHERPA package, since it is used for the merging procedure of matrix elements and the parton shower.

## 4 Physics set-up

In this section those packages are presented that define the overall physics set-up. Clearly, this contains the specification of the physics model, in which cross sections are calculated or events are generated. Such a physics model defines the set of particles in it as well as most of their properties, including their mutual interactions. Equally important is a declaration of which type of process is discussed. Basically this amounts to a definition of incoming beams and their structures, both in terms of their respective energy spread and in terms of their eventual partonic substructure, which can be parametrised by parton distribution functions. In the following, therefore, the packages MODEL, BEAM, and PDF are briefly introduced. Within SHERPA they define the physics model, the structure of the incoming beams and the eventual inner structure of the colliding particles, respectively.

The package MODEL encapsulates abstract structures to specify arbitrary parameter sets of physical models, e.g. coupling constants, Yukawa masses, decay widths, etc.. For a certain physical model, for instance the Standard Model or its minimal super-symmetric extension, all parameters are represented by a Model object derived from the abstract base class Model\_Base. This base class and its explicit instances mainly serve as containers and handle the input and the access to the parameters. The main ingredients of this class are lists of four standard parameter types:

* ScalarNumber for integer constants,
* ScalarConstant for floating point (double precision) constants,
* ScalarFunction for real single-parameter functions, derived from the abstract class ATOOLS::Function\_Base, and
* ComplexMatrix for a matrix of complex floating point (double precision) constants.

Examples of parameters, which could be contained in the lists, are the number of extra dimensions, $`\alpha `$ in the Thomson limit, the running strong coupling constant $`\alpha _s`$, and the CKM-matrix, respectively. Each parameter is mapped on a name string, which is used for all references on the parameter. A code example for the insertion of such a pair of name and parameter into the list of scalar constants reads

```
   p_constants->insert(std::make_pair(std::string("ALPHAQED(0)"),
                                      1./137.03599976));

```

To access parameters, the class Model\_Base defines a function for each parameter type, for instance the constant "ALPHAQED(0)" can be re-obtained through a call of

```
   ScalarConstant("ALPHAQED(0)");

```

There are two typical situations for setting the parameters of a certain model. First, they can be simply read-in from a file, which by default is called Model.dat. As a second possibility, Model\_Base is equipped with a pointer to a Spectrum\_Generator\_Base object. This object provides an abstract interface to external spectrum generators with methods to read-in input parameters, to deduce the particle spectrum and to calculate the other parameters of this model. So far, interfaces to the Fortran codes Hdecay  and Isajet  have been constructed. They are instances of the abstract base class Spectrum\_Generator\_Base and they are called Hdecay\_Fortran\_Interface and Isajet\_Fortran\_Interface, respectively. To include more of these generators, a user would have to derive such an interface class and provide methods to read-in the input parameter set, to calculate the other parameters and to modify the particle spectrum accordingly. It should be noted that for the inclusion of new particles, also the class Flavour would have to be extended correspondingly333Using the new accord on a generic interface structure for spectrum generators, , the task to inherit new instances of the Spectrum\_Generator\_Base will be substantially alleviated..

Within SHERPA the original beams of a specific collider are treated in two different stages in order to extract the partonic initial states for the hard interactions. In the first step, the incoming beams at a certain energy, the nominal energy of the collider, are transfered into bunches of interacting particles, which have an energy distribution, and whose momenta are distributed collinearly w.r.t. the original beams. Two options are currently implemented: the beams can either be monochromatic, and therefore need no extra treatment, or, for the case of an electron collider, Laser backscattering off the electrons is supported. This mode leads to photon bunches with a certain energy and polarisation distribution. In a second step, possible substructures of the bunch particles are taken into account, as well as ordinary initial state radiation. This task is achieved by means of parton distribution functions (PDFs) or simple structure functions for the case of electron ISR.

As an illustrative example, consider the case of resolved photon interactions at an electron collider. As stated above, by Laser backscattering the incoming electrons can be “transformed” into photons distributed in energy and polarisation depending on the parameters chosen for the incoming electron beam and the Laser. This corresponds to the first step. In the second step, these photons have a partonic substructure described by an appropriate photon PDF defining the probability to find a certain parton flavour at the scale $`Q^2`$ and the energy fraction $`x`$ inside the photon.

The first stage is hosted in the module BEAM, housing all classes that are employed to generate beam spectra. The handler class to access different beam-manipulation strategies is Beam\_Spectra\_Handler. Before coming into full effect during integration or event generation, this handler initialises a suitable treatment (Beam\_Bases) for both beams and uses them to generate corresponding weights, i.e. energy distributions. At the moment, all outgoing bunch particles are still collinear to the incoming beams, but this is going to change in the future, by adding transversal boosts to the kinematics. Up to now two types of Beam\_Bases are supported: Monochromatic beams, and the generation of photon beams via Laser\_Backscattering. For the latter one the parametrisation of  is supplied in addition to a simple theoretical ansatz. To flatten out the peaks in the energy distribution of the produced photons, additional phase-space mappings have been introduced, which are located in the module PHASIC++ and come to action as further channels in a multi-channel phase-space sampling  also implemented there. For more details, cf. Sec. 5. To implement any new beam treatment, such as, e.g., Beamstrahlung, a corresponding instance of the class Beam\_Base has to be provided. In addition, the construction of extra phase-space mappings might become mandatory.

The second stage, i.e. the handling of initial state radiation or partonic substructures, is located in the PDF module. The handler class steering the selection of PDFs or structure functions of bunch particles is the PDF\_Handler, instantiating a suitable PDF\_Base object and returning a pointer to it. So far, a structure function for electrons (that can handle charged leptons in general), a photon PDF and various proton structure functions are available. The list of proton PDFs covers: a C++ version of MRST99 , the Fortran CTEQ6 PDF , and the set of LHAPDFs . The two Fortran pieces are encapsulated by the two classes CTEQ6\_Fortran\_Interface and LHAPDF\_Fortran\_Interface. For the case of photon bunches, the only structure function implemented is the GRV (LO) parton density , again framed by a C++ class, GRVph\_Fortran\_Interface. Having selected and initialised all required PDFs the PDF\_Base objects are handed over to the ISR\_Handler via pointers to two ISR\_Base objects. If no ISR treatment is necessary for a beam the ISR\_Base is instantiated as an Intact object, else a Structure\_Function object is instantiated, which possesses a pointer to the corresponding PDF\_Base. At first glance this construction looks quite over-engineered, however, it allows for a straightforward implementation of possible multi-parton structure functions, which one would possibly like to use to correctly account for multiple interactions. To efficiently sample initial state radiation or parton distributions, and similar to the beam treatment, qualified phase-space mappings have been constructed, taking into account the peak structure of the corresponding distributions. It is also worth noting that the PDFs are handed over to the Shower\_Handler in order to facilitate the backward evolution of initial-state parton showers, see Sec. 8.

## 5 Matrix elements and phase space integration

In the SHERPA framework, hard matrix elements occur in different phases of event generation, i.e. in the generation of the (hardest) signal process, in the decay of heavy unstable particles, or during the simulation of multiple parton interactions. This is reflected by the appearance of different Event\_Phase\_Handlers during event generation. In fact, event generation starts with an empty list of blobs. The first blob to be filled by the Signal\_Processes event phase is, obviously, for the partonic signal process. This event phase, like the other ones, such as Hard\_Decays and Multiple\_Interactions, owns a pointer to an appropriate handler for the matrix elements.

As briefly mentioned before, SHERPA currently incorporates two modules concerned with matrix elements for hard partonic subprocesses. These modules are interfaced through the Matrix\_Element\_Handler, which in turn possesses public methods for the set-up of the calculation framework (physics model, beam spectra, PDFs, construction of suitable, process- and framework-dependent integration channels), for the evaluation of total cross sections, and for the generation of single events. These tasks as well as some management issues (number and flavour of partons, etc.) look very similar on an abstract level, and in fact, the corresponding methods just call their counterparts in the specific matrix element realisation. There is one difference, however, in these modules. The analytically known $`22`$ processes incorporated in the module EXTRA\_XS provide the colour structure of individual parton configurations through specific methods. SetColours defines this structure in terms of the external four-momenta, whereas Colours returns the colour structure. In AMEGIC++ things are not so easy. In fact, in SHERPA the colour structure of an $`n`$-parton configuration is reconstructed by backward clustering, which is guided by the individual Feynman diagrams, cf. Sec. 8. This algorithm allows, in principle, to reconstruct colour flows for any multi-parton configuration in a leading-log large-$`N_c`$ scheme for any parton level generator. The only ingredient that has to be delivered by the parton-level generators is a representation of Feynman diagrams in terms of binary trees. Therefore, AMEGIC++ provides methods to access the amplitudes. This difference is also reflected in the Matrix\_Element\_Handler. It allows to either directly access the class responsible for the hard $`22`$ subprocesses in the case of EXTRA\_XS or to extract individual Feynman diagrams from AMEGIC++.

The library EXTRA\_XS supplies a list of simple $`22`$ processes at leading order and their analytically known differential cross sections. Thus it allows for a fast evaluation of such processes. At present it includes all $`22`$ QCD and Drell-Yan processes with massless partons. Furthermore, it is employed for the determination of the initial colour configuration for the parton shower during event generation. When AMEGIC++ is used as signal generator, this applies after an appropriate backward clustering, cf. Sec. 8.

Within EXTRA\_XS each process object is inherited from the base class XS\_Base, which contains the basic ingredients for a $`22`$ signal generator. This amounts to methods providing the particle types, the total and differential cross section of the process, and to methods that allow the generation of single parton-level events and the determination of their colour structure. In the set-up of such an XS\_Base the overall physics model, the beam spectra and the ISR strategy have to be handed over as well. The latter information is employed to select adequate initial state channels for the phase-space integration (see below). Since only $`22`$ processes are taken into account within EXTRA\_XS, its final state part boils down to simple hard wired S-, T\- and U-channel integrators. According to its specific purpose, an XS\_Base object may either correspond to a single $`22`$ process represented by an instance of the class Single\_XS or to a set of processes represented by the container class XS\_Group. However, if a user wants to set up his own process, he or she has to derive it from Single\_XS and to define all its process-specific properties, such as the colour structure of the particles involved, the differential cross section or the final state channels. The overall interface from EXTRA\_XS to the SHERPA framework is the special XS\_Group called Simple\_XSecs, which can be accessed through the Matrix\_Element\_Handler and serves as a signal generator. This class also contains methods to read-in user-defined run-specific subprocesses and to select and initialise the corresponding XS\_Bases.

AMEGIC++ is SHERPA’s prefered multipurpose matrix-element generator concerned with the production and evaluation of matrix elements for hard processes in particle collisions at the tree-level. A manual for the current version 2.0 is in preparation, superseding an older one, . This new version now also covers the full Minimal Supersymmetric Standard Model (MSSM)  and the ADD model  of large extra dimensions; for details concerning the implementation of the latter one, see .

In its instantiation, AMEGIC++ is equipped with pointers to a Model\_Base object, to a Beam\_Spectra\_Handler and to an ISR\_Handler object. The first one supplies all coupling constants and model specific parameters that allow AMEGIC++ to construct a list of all available Feynman rules, i.e. vertices, for the chosen physical model. They are represented through objects of the type Single\_Vertex, which possess pointers to a Lorentz\_Function and a Color\_Function object accounting for the intrinsic Lorentz and $`SU(3)`$ colour structure of the vertex. This is nicely exemplified by the triple gluon vertex:

```
  Kabbala kcpl0 = -g3;
  Kabbala kcpl1 = kcpl0;

  for (short int i=0;i<3;i++)
    vertex[vanz].in[i] = Flavour(kf::gluon);

  vertex[vanz].cpl[0]        = kcpl0.Value();
  vertex[vanz].cpl[1]        = kcpl1.Value();
  vertex[vanz].cpl[2]        = 0.;
  vertex[vanz].cpl[3]        = 0.;
  vertex[vanz].Str           = (kcpl0*PR+kcpl1*PL).String();

  vertex[vanz].ncf           = 1;
  vertex[vanz].Color         = new Color_Function(cf::F);
  vertex[vanz].Color->SetParticleArg(0,2,1);
  vertex[vanz].Color->SetStringArg(’0’,’2’,’1’);

  vertex[vanz].nlf           = 1;
  vertex[vanz].Lorentz       = new Lorentz_Function(lf::Gauge3);
  vertex[vanz].Lorentz->SetParticleArg(0,1,2);

  vertex[vanz].on            = 1;
  vanz++;

```

To extend AMEGIC++ and incorporate new interaction models, a potential user would just have to derive a corresponding class from the Interaction\_Model\_Base class and to fill it with suitable vertices.

Having specified a process or a group of processes to be evaluated, AMEGIC++ then constructs all Feynman diagrams by matching the set of vertices onto topologies generated beforehand. These amplitudes are translated into helicity amplitudes, which are subject of various manipulations, all aiming at a reduction of the calculational cost of the entire computation. As a further step AMEGIC++ analyses all individual Feynman diagrams and, according to their phase-space singularities, it automatically generates appropriate phase-space mappings for the integration over the final state. For more details on the multi-channel integration, see below. The integration channels as well as the helicity amplitudes are stored as library files that have to be compiled once and are linked to the main program. The by far most convincing features of the AMEGIC++ module are its robustness and flexibility. The package offers the evaluation of arbitrary processes444AMEGIC++ has proved to work for up to six final state particles . in the Standard Model, and in two of its extensions, the MSSM and the ADD model.

The tools for phase-space integrations, i.e. simple integration channels, building blocks for complex phase-space mappings and the full set of multi-channel integration  routines are hosted in the package PHASIC++. It is used by AMEGIC++ as well as by the simple matrix elements located in the EXTRA\_XS package. If needed, it can be adjusted in a straightforward fashion for usage by any other matrix element generator. The only thing, one would have to do, is to provide information about or to directly construct the channels for the final state part. Both strategies are realized by EXTRA\_XS and by AMEGIC++, respectively. In the latter case, the class responsible for the construction of the full final-state multi-channel integrator is the Phase\_Space\_Generator, individual channels are constructed by the Channel\_Generator through a mapping of the Feynman diagrams onto the Channel\_Elements supplemented by PHASIC++.

Apart from the matrix-element-specific final-state channels, during the phase-space integration one might have to sample over all initial-state configurations. Within SHERPA initial states on the parton level are constructed from the incoming beams in two steps. First, the beam particles might be transformed into other particles (such as electrons into photons through Laser backscattering) or may experience some smearing (such as electrons through Beamstrahlung). The resulting particles, which may or may not have an energy distribution, might have a resolved partonic substructure parametrised by PDFs or they might experience additional initial state radiation, which can also be parametrised by a PDF-like structure. To guarantee optimal integration performance, one has to analyse the emerging energy distributions in each of the two steps and flatten them out. This results in up to two more multi-channel mappings, one for the beam centre-of-mass system, and one for the parton-level centre-of-mass system. Both systems currently are defined through the boost relative to their ancestors and by their respective centre-of-mass energy squared. In the near future, also transversal boosts of the subsystems will be included. This, however, is a straightforward extension of existing code.

## 6 Decays of unstable particles

Decays of heavy unstable particles during the generation of an event are treated by a specific Event\_Phase\_Handler called Hard\_Decays. This handler owns, not surprisingly, an interface to matrix elements responsible for the description of such decays on the parton level. Again, this interface, the Hard\_Decay\_Handler, is separated from the physics implementation, namely the matrix elements. Currently, only the matrix elements of AMEGIC++ are accessible through this interface.

At the moment, heavy unstable particles are produced by hard matrix elements only, i.e. through the actions of the following event phases: Signal\_Processes, Hard\_Processes and Multiple\_Interactions. While processing each of these phases, it is checked whether unstable particles emerge. If this is the case, their respective decay channel and the effective mass of this decay are determined. The decay channel is selected by invoking the Hard\_Decay\_Handler, which provides a mapping of particles to decay tables and the corresponding matrix elements for each decay channel. Hence, a pointer to this interface is a member of all the event phases above. The effective mass is distributed according to a Breit–Wigner function, the method for this resides in the Particle object itself. Fixing the decay channel before the mass is determined ensures that the correct, initialised branching ratios are recovered. In principle, this also allows for using tree-level decay kinematics as supplemented by, e.g., AMEGIC++ together with higher order branching ratios555Such a procedure might seem somewhat inconsistent. However, using loop-corrections for, say, two-body decays, basically amounts to a specific choice of scale of the coupling constant(s) involved. In this sense, inconsistencies are due to different choices of scale, which could be fixed and compensated for in the corresponding vertices.. After all masses are fixed, the four-momenta of all particles emerging in the corresponding hard subprocess (all particles leaving the blob) are shifted to their new mass-shell accordingly. This induces some minimal modifications of the energy-momentum relations of the particles and might affect the mutual respective angles. However, the four-momentum of the total system stays fixed. Eventually, after some jet evolution took place, the unstable particles are decayed, maybe giving rise to more unstable particles or new jets and, thus, triggering more actions of the Hard\_Decays or Jet\_Evolution phase.

At the moment, the procedure outlined above is being implemented and tested. In its current, minimal form, two issues have not been tackled:

* In principle, attaching secondary radiation to hard decays leads to multi-scale parton showers , which act in the following way: In a first step the parton shower evolves the parton configuration down to scales comparable to the width of the decaying particles. Then, these particles decay, eventually starting an initial and a final state parton shower, which have to be matched with the preceeding one. Finally, the emerging parton ensemble is evolved down to the next decay or the infrared scale. An implementation of this procedure is straightforward in the SHERPA framework.
* Furthermore, spin correlations in the fashion of  should be added. The underlying idea is as follows. When decays of heavy unstable particles are treated in the way outlined above, implicitly some narrow width approximation has been used. In fact, this inherent assumption only allows to cut the propagators of the unstable particles666In other words, if the decaying particles’ width becomes large, all processes, i.e. also the “continuum” or background, contributing to the same final state have to be taken into account.. Under the narrow width approximation, one can decompose the propagator into a sum over physical polarisation states. The polarisations of a number of outgoing particles produced in one interaction, however, are correlated, and this correlation propagates to a correlation in the kinematical distribution of the decay products.

## 7 Multiple interactions

Multiple interactions are handled within the SHERPA framework by the Event\_Phase\_Handler called Multiple\_Interactions. Given a Blob list, which already contains the signal process, it adds one by one hard $`22`$ subprocesses, according to an ordering in the transverse momentum $`p_{}`$ of the outgoing particles. The initial conditions for this sequence of parton interactions are determined by the signal process. However, it might happen that the signal process contains more than two outgoing particles and, thus, the definition of $`p_{}`$ is ambiguous. Then, the backward clustering already employed to create an interface from the signal process to the parton shower (see Sec. 8) defines the corresponding $`22`$ process. The sequence of further partonic $`22`$ interactions results in new Blobs, each of which experiences its own shower evolution through the action of the Jet\_Evolution event phase.

To create the additional hard subprocesses, the Multiple\_Interactions phase employs a MI\_Handler, the interface to the new module AMISIC++. This module is concerned with the generation of hard underlying events similar to how this is simulated in Pythia . There, the hard underlying event is assumed to be a mostly incoherent sum of individual scattering processes. Right now, AMISIC++ is restricted to hard QCD processes and therefore employs the library of EXTRA\_XS, (see Sec. 5). To account for a fast performance, however, AMISIC++ does neither evaluate matrix elements on-line nor uses a veto algorithm as proposed in . Instead it pre-calculates and tabulates the appropriate differential cross sections and stores them to disk in the initialisation phase. This data may then also serve for future runs.

It should be noted here that AMISIC++ is in the process of full implementation and of careful tests only. Furthermore, the description of the soft underlying event is still lacking in Multiple\_Interactions.

## 8 The interface to fragmentation

Having produced a number of partons in hard subprocesses – either the signal process, hard particle decays, or multiple hard partonic interactions – these coloured objects have to be transformed into colourless hadrons. The gap between the varying scales of these hard interactions and some universal scale connected to hadronisation is bridged by parton showers. Invoking the parton shower fills in further parton radiation and guarantees the universality of the scale, where the phenomenological hadronisation model sets in, and of its parameters.

Within the SHERPA framework, such additional emission in general happens during an event phase called Jet\_Evolution. This event phase adds blobs describing radiation of secondary partons to the list of blobs constituting the event. To this end, all parton configurations in blobs for signal processes, hard decays, or for multiple parton interactions have to be analysed and modified by parton showers. The Jet\_Evolution, thus, owns pointers to all corresponding Matrix\_Element\_Handlers for the definition of colour configurations and other starting conditions of the parton shower and to a Shower\_Handler. This object provides public methods that allow to initialise and perform showers and to insert the resulting shower blobs into the event record. In principle, one can think of using different shower realisations, for instance a dipole cascade as in Ariadne , an angular ordered shower as in Herwig , or a virtuality ordered shower as in Pythia . So far, in SHERPA a virtuality-ordered shower has been implemented through a separate module called APACIC++ . This module also includes the functionality needed for the merging of parton showers and matrix elements in the fashion of , i.e. a veto on jets at the parton level. The implementation of other approaches that model multiple emission of secondary partons will not substantially change the interface Shower\_Handler.

From the brief description above, it is clear that the matrix elements and the parton showers might act on different objects. In the case realized so far, i.e. in the case of APACIC++, the parton shower is formulated in terms of trees and knots; for a shower described in the fashion of Ariadne one could imagine that dipole objects are the basic terms. Hence, in the case of APACIC++ being the parton shower generator the Jet\_Evolution would have to administer the translation of partons to knots, i.e. the definition of a primordial tree structure representing a parton configuration. This is done through suitable interfaces. The specific instantiation of the abstract base class Perturbative\_Interface depends on the form of the matrix elements and their functionality inside the Matrix\_Element\_Handler, and on the Shower\_Handler itself. The application of these interfaces is mandatory for the Jet\_Evolution and results in some “merging blobs” around the blob of the hard subprocess under consideration. These merging blobs are needed for the sake of four-momentum conservation, since secondary emission a posteriori gives a virtual mass to the primary on-shell partons, which has to be balanced by shifting the four-momenta of the primary parton ensemble. All of these interfaces are part of the SHERPA framework itself rather than of the individual modules (such as AMEGIC++ etc.). Due to the merging algorithm, this interface needs to supply the possibility to calculate Sudakov weights, and to accept or reject parton configurations according to them. It is clear that a rejection necessitates a new parton configuration and, therefore, results in a new event to be supplied by the Matrix\_Element\_Handler. Correspondingly, a new Blob is filled by the Signal\_Processes event phase. However, since at the moment only two specific matrix element generators are available, cf. Sec. 5, only two realisations of the Perturbative\_Interface exist, namely SimpleXS\_Apacic\_Interface and Amegic\_Apacic\_Interface.

The former is very simple, since the library of $`22`$ subprocesses is used such that additional jets are the result of the simulation of the radiation activity through the parton showers. Therefore, in this case, no veto on extra jets has to be performed inside a shower and consequently no Sudakov form factor has to be applied. Furthermore, the colour structure of the partons as well as the hard scale of the subprocess can be obtained directly from the XS\_Bases inside EXTRA\_XS through simple access methods made available to the SimpleXS\_Apacic\_Interface. The starting conditions for the shower are obtained in quite a straightforward fashion. The initial virtualities for the shower evolution are given by the scale of the hard subprocess, which is connected to the maximal momentum transfer along coloured lines. The maximal opening angle of the next emission for each parton is obtained from the angles w.r.t. to the colour connected partons in the hard $`22`$ process. The parton shower is then simply initialised by filling this information into the trees of APACIC++.

When using AMEGIC++ or any other matrix element generator involving $`2n`$ processes with $`n>3`$ the situation is more complicated. In such cases, the $`2n`$ configuration is reduced to a “core” $`22`$ process through the $`k_{}`$-cluster algorithm. To keep track of allowed and disallowed clusterings, i.e. of actual Feynman rules, the clustering follows the Feynman diagrams of the corresponding matrix element. They are obtained through the Matrix\_Element\_Handler. For each clustering, a Sudakov form factor is evaluated and attached as an extra weight (for details see ), which finally results in an overall weight for this specific parton-level event. In case it is accepted, the initial colour structure is fixed by the colour structure of the core $`22`$ process, since the parton shower inherently is formulated in the large $`N_c`$-approximation. In the clustering procedure the tree structure for the parton shower already has been constructed. It is supplemented with missing information (i.e. the starting virtualities for each parton, opening angles etc.) through the principle that the parton shower evolution of each parton is defined through the node in which it was produced first.

This condenses in the following algorithm: going from inner knots to the outer ones, in each node it is decided by the Perturbative\_Interface which emerging parton is the harder, i.e. more energetic, one. The winner inherits the starting scale and angle of the decaying mother, the losers starting conditions are defined through the actual node. The starting conditions of the first four partons stem from the core $`22`$ subprocess.

As already stated, the interface to the showers and the actual physics implementation are separated. Whereas the interface is located in the Shower\_Handler, the first physics implementation of a parton shower is encapsulated in the independent module APACIC++. It provides a virtuality ordered parton shower, supplemented with angular ordering enforced “by hand”, similar to the one realized in Pythia. One of the major differences, however, is that in SHERPA matrix elements for arbitrary parton configurations are merged consistently with the parton shower. This merging procedure results in constraints on the parton shower, which must not produce any parton emission that would have to be interpreted as the production of an extra jet, since jet production is left to the corresponding matrix elements.

The parton shower in APACIC++ is organised recursively in terms of binary tree structures, where the emission of an additional parton is understood as a branching process giving rise to another node, a Knot, inside the Tree777These trees are the only objects of APACIC++, which are handed over to the Shower\_Handler in order to be filled with partons subject to further emission. This process is triggered by the Shower\_Handler and managed by the Hard\_Interface, the class managing the access to APACIC++. In the evolution of the tree the binary branches are defined through splitting functions, which are represented by objects of similar name, i.e. by derivatives of the base class Splitting\_Function. These objects contain methods to determine outgoing flavours of a branching process and their kinematics. Since in APACIC++ the parton shower proceeds through a hit-or-miss method, functions overestimating the integral of a splitting function in certain boundaries and corresponding correction weights are also included. For the incorporation of new branching modes, such as for the simulation of parton showers off super-symmetric particles, just a suitable derivative of the base class has to be added. The sequence of branches within the parton shower is defined through Sudakov form factors. Consequently, such objects are also used by APACIC++. For the description of parton showers in the initial state, backward evolution relying on the parton distribution functions usually is employed. Therefore, the corresponding PDFs are handed over to APACIC++ and used in the space-like showers and Sudakov form factors. Here, it should be briefly mentioned that the Sudakov form factors, in principle, provide only the trees of branching processes. There, each node is supplemented by the scale, where the branching takes place, and the distribution of energies. The corresponding determination of the actual kinematics is separated from the implementation of the Sudakov form factors; it is located in extra classes. However, once the parton shower has terminated, the tree structure is translated back into partons. The interface, i.e. the Shower\_Handler, will provide blobs with one incoming parton stemming from the hard matrix element, which is identified as the jet’s seed, and a number of outgoing partons exhibiting the partonic structure of the jet before hadronisation sets in.

## 9 Hadronisation & soft physics aspects

After the parton shower described above has terminated, one is left with a configuration of coloured partons at some low scale of the order of a few GeV in transverse momentum. These partons, in order to match experiments, have to be translated into white hadrons. Within SHERPA, this transition occurs in an event phase called Hadronisation. This Event\_Phase\_Handler contains interfaces to two physics tasks related to this phase.

First of all, extracting a coloured parton from a white initial hadron (such as in collisions involving protons), necessitates to describe the colour structure of its remnant. This is achieved by the Beam\_Remnant\_Handler.

It is clear that the coloured constituents will be colour connected to other partons in the final state, thus influencing properties of the event at hadron level. The distribution of colour over the hadron remnants is a tricky task, well beyond perturbation theory. This immediately implies that phenomenological models have to be employed. For instance, one could assume that such a model is guided by the attempt to minimise the string length of the colour string spanned by the outgoing partons. Therefore, within SHERPA the beam remnants arising from hadrons are currently handled in a naive approach. Given a list of Blobs, all initiators of initial state showers are extracted and attached to a beam blob, which represents the breakup of the incoming hadron. Beam-remnant partons are added such that the flavour quantum numbers of the hadron are recovered step by step. Colours are distributed in a randomised fashion, where, of course, gluons or quarks carry two or one colour index different from zero, respectively. Again, these indices are distributed such that they add up to a white hadron. The energies of the additional parton remnants are distributed either according to PDFs or to a phenomenological function like the one in . Finally, all particles obtain a mild $`k_{}`$-kick according to a Gaussian distribution.

The resulting final parton configuration then originates from the perturbative event phases, i.e. from Signal\_Processes, Hard\_Decays, Multiple\_Interactions or Jet\_Evolution, or from the beam remnants as described above888Altogether these partons must form a colour singlet, although, if baryon-number violating sub-processes are implemented, it might be difficult to recover them as singlets in the large $`N_c`$-representation inherent to event generation.. The Hadronisation phase has to translate these coloured partons into white hadrons. For this purpose, it employs its Fragmentation\_Handler, which provides an interface to phenomenological hadronisation models.

The Fragmentation\_Handler first of all sorts the partons into disconnected chains starting with a colour-triplet, such as a quark, and ending with a parton in a colour-anti-triplet state, such as an anti-quark. Then, within these chains, partons are shifted to their constituent mass-shells, if necessary. Only then, the selected individual hadronisation model is invoked. This mass-shift inside the Fragmentation\_Handler guarantees the independence of the perturbative phase, which presumably is formulated in terms of current masses, and the non-perturbative phase with its constituent masses. Especially for cluster-fragmentation models  relying on the breakup of massive gluons into constituent quarks this is clearly advantageous. However, at the moment only the Lund string model  is implemented as a specific hadronisation model to be used by the Fragmentation\_Handler. Its implementation within Pythia is accessible through a special Lund\_Fortran\_Interface class, which also reads in some of the parameters needed in this model from a corresponding data file. In the near future, also a new version of the cluster-hadronisation model  will be made available.

This model will be added as a new module, AHADIC++, to the overall framework. This module just finished construction and currently is being tested. It performs the transition from partons to primary hadrons in two steps: first of all, the gluons experience a forced decay into colour-triplet pairs, which allows to decompose the parton sinlget chain into clusters. The clusters are built from one triplet–anti-triplet pair and thus have the quantum numbers of hadrons, including those of baryons. In this step of cluster formation effects of soft colour reconnection are modelled, which is an extension to the previous versions of the cluster model . In the next step, the clusters decay either into lighter ones, or into the primary hadrons. The respective decay mode depends on the cluster mass and on the masses emerging for the resulting four-vectors. The distribution of the decay products’ momenta is governed by some universal anisotropic kinematics, the selection of the decay mode thus reflects a constituent-flavour-dependent separation into a cluster and a hadron regime. There, also soft colour reconnection effects are taken into account. In the rare case that a primary cluster already is inside the hadron regime a one-particle transition is enforced. For more details on this model, cf. .

In any case, invoking the Fragmentation\_Handler results in a number of colour singlet parton chains, each of which enters a new Blob, producing a number of primordial hadrons. These hadrons may or may not decay further; at the moment, the subsequent hadron decays are also handled through the Lund\_Fortran\_Interface. In the future, however, it is envisioned to have an extra event phase Hadron\_Decays and specific interfaces. Each of the hadron decays is then represented by another Blob, allowing to reconstruct displaced vertices etc..

## 10 Summary & outlook

In this publication a proof-of-concept version of the new event-generation framework SHERPA, Simluation for High-Energy Reactions of PArticles, has been presented in its version 1.$`\alpha `$. Its construction is a still on-going process, which is based on three programming paradigms, namely modularity, the separation of interface and physics implementation and a bottom-to-top approach for the addition of further modules. In its overall structure, SHERPA reflects a typical, event-generator-inherent simulation of full events through disjoint event phases. This lends itself to modularisation and, therefore, SHERPA is entirely written in the object-oriented programming language C++.

So far a number of physics modules have been attached to SHERPA, which allow users to fully simulate electron–positron or unresolved photon–photon collisions at high energies. Also, fully hadronic collisions, such as, e.g., proton–anti-proton or proton–proton reactions, can be simulated. In the description of such events, however, some features, for instance the soft underlying event, are still lacking or basically not tested yet. In all cases considered so far, SHERPA proved to be flexible and to live up for all demands. More tests and the inclusion of further, nearly ready physics modules, such as a new version of the cluster hadronisation, hard decays of unstable heavy particles, or an underlying event model, will be in the focus of future work.

SHERPA can be obtained through the downloads section of:

```
http://www.physik.tu-dresden.de/~krauss/hep/index.html

```

## Acknowledgements

F.K. wants to acknowledge financial support by the EC 5th Framework Programme under contract number HPMF-CT-2002-01663. Further financial support by BMBF, DFG and GSI is gratefully acknowledged.
The authors are grateful for fruitful discussions with Stefan Gieseke, Klaus Hamacher, Hendrik Hoeth, Leif Lönnblad, Alberto Ribon, Gerhard Soff, Philip Stevens, and Bryan Webber. Also, the authors owe a great deal to users of SHERPA, which have reported on bugs and shortcomings, in particular Claude Charlot, Alessio Ghezzi, Hendrik Hoeth, Huber Nieto, and Thorsten Wengler. Without all this help such a task would be unsurmountable.