Hidden Valley Processes
 
  - Particle content and properties
- Production processes
- Timelike showers
- Hadronization
- Event information
This Hidden Valley (HV) scenarios have been developed specifically 
to allow the study of visible consequences of radiation and 
hadronization in a hidden sector, by recoil effect and by decays 
back into the visible sector. A key aspect therefore is that 
the normal timelike showering machinery has been expanded with a 
third kind of radiation, in addition to the QCD and QED ones. 
These three kinds of radiation are fully interleaved, i.e. 
evolution occurs in a common pT-ordered sequence. 
The scenario is described in [Car10]. Furthermore 
hadronization in the hidden sector has been implemented. 
Three main scenarios for production into and decay out of the 
hidden sector can be compared, in each case either for an 
Abelian or a non-Abelian gauge group in the HV. Further details 
are found in [Car11]. It is strongly recommended that you 
read this article, at least sections 2 and 3, and the appendix A, 
before you begin any Hidden Valley simulation. The brief physics 
paragraphs below are intended as a refresher for people with such 
prior knowledge, not as a complete description. In addition, some 
recent extensions are described, not (yet) documented elsewhere.
 
Warning: several alternative hadronization scenarios 
will not work in conjunction with Hidden Valley processes, which has 
been developed exclusively on top of the default scenario. Known 
examples of such incompatible alternatives include 
StringPT:thermalModel = on, 
StringPT:mT2suppression = on and 
Ropewalk:RopeHadronization = on, but there may be more. 
 
 
Particle content and properties
 
 
For simplicity we assume that the HV contains a broken U(1) 
or an unbroken SU(N) gauge symmetry. This is used in the 
calculation of production cross sections. These could be rescaled 
by hand for other gauge groups. 
 
mode   HiddenValley:Ngauge   
 (default = 3; minimum = 1)
is U(1) for Ngauge = 1, is SU(N) if 
Ngauge > 1. Note that pair production cross sections 
contains a factor of Ngauge for new particles 
in the fundamental representation of this group. 
   
 
 
A minimal HV particle content has been introduced. Firstly, there is 
a set of 12 particles that mirrors the Standard Model flavour 
structure, and is charged under both the SM and the HV symmetry groups. 
Each new particle couples flavour-diagonally to a corresponding SM 
state, and has the same SM charge and colour, but in addition is in 
the fundamental representation of the HV colour, as follows: 
Dv, identity 4900001, partner to the normal 
d quark; 
Uv, identity 4900002, partner to the normal 
u quark; 
Sv, identity 4900003, partner to the normal 
s quark; 
Cv, identity 4900004, partner to the normal 
c quark; 
Bv, identity 4900005, partner to the normal 
b quark; 
Tv, identity 4900006, partner to the normal 
t quark; 
Ev, identity 4900011, partner to the normal 
e lepton; 
nuEv, identity 4900012, partner to the normal 
nue neutrino; 
MUv, identity 4900013, partner to the normal 
mu lepton; 
nuMUv, identity 4900014, partner to the normal 
numu neutrino; 
TAUv, identity 4900015, partner to the normal 
tau lepton; 
nuTAUv, identity 4900016, partner to the normal 
nutau neutrino. 
Collectively we will refer to these states as Fv; 
note, however, that they need not be fermions themselves. 
 
 
In addition the model contains the HV gauge particle, either 
a HV-gluon or a HV-photon, but not both; see Ngauge 
above: 
gv, identity 4900021, is the massless 
gauge boson of the HV SU(N) group; 
gammav, identity 4900022,  is the massless 
gauge boson of the HV U(1) group. 
 
 
Finally, for the basic HV scenario, there is a new massive particle 
with only HV charge sitting in the fundamental representation of the 
HV gauge group: 
qv, identity 4900101. 
Optionally up to eight different such flavours can be allowed in 
the hidden sector, identities 4900101 - 4900108. The actual number 
used is set by HiddenValley:nFlav, see further below. 
 
Currently there are two main production scenarios implemented. 
 
 
The first is for pair production of one of the 
states presented first above, e.g. g g → Dv Dvbar. 
Such a Dv can radiate gluons and photons like an SM quark, 
but in addition HV-gluons or HV-photons in a similar fashion. 
Eventually the Dv will decay like Dv → d + qv. 
The strength of this decay is not set as such, but is implicit in 
your choice of width for the Dv state. Thereafter the 
d and qv can radiate further within their 
respective sectors. The qv, gv and gammav 
are invisible. 
 
 
The second is a variant of a Z' resonance: 
Zv, identity 4900023, a boson that can couple 
both to pairs of Standard Model fermions and to qv qvbar 
pairs. Mass, total width and branching ratios can be set as convenient. 
This opens up for other processes, notably 
l^+l^-, q qbar → Zv → qv qvbar. 
 
 
Some further scenarios can easily be implemented by a brute-force 
addition of a new decay channel to an existing particle. An example 
would be a Higgs portal, where the Higgs can decay into a 
qv qvbar or gv gv pair. 
 
 
The possibility of a leakage back from the hidden sector will be 
considered in the Hadronization section below. For the U(1) 
case the gammav normally acquires a mass and can decay back to 
a Standard-Model fermion pair, while the qv remains invisible. 
The SU(N) alternative remains unbroken, so confinement holds 
and the gv is massless. A string like 
qv - gv - ... - gv - qvbar can break by the production of 
new qv - qvbar pairs, which will produce qv-qvbar 
mesons. For this kind of scenarios it makes sense to assume that 
qv has spin 1/2, so that QCD provides some guidance. 
It is possible to build a rather sophisticated hidden sector 
by trivial extensions of the HV flavour content. In most contexts 
this would be overkill, since much of the finer details would not 
be observable in our sector. The default therefore is a simplified 
treatment. 
 
Hidden Valley hadrons in a simple setup
 
 
 
In the default HV-hadron option, 
HiddenValley:separateFlav = off, 
the qv can be duplicated in up to 
eight copies, with identical properties except for the flavour charge. 
Specifically, you can set the mass of the first qv, but 
then that value is propagated to the other masses at initialization. 
These are assigned codes 4900101 - 4900108. This gives a total of 64 
possible lowest-lying mesons. We also include a duplication of that, 
into two multiplets, corresponding to the pseudoscalar and vector 
mesons of QCD. These are assumed to have the same mass and other 
properties. Only the flavour-diagonal ones can decay back into the 
Standard-Model sector, however, while the rest remain in the hidden 
sector. It is therefore only necessary to distinguish a few states: 
pivDiag, identity 4900111, a flavour-diagonal 
HV-meson with spin 0 that can decay back into the Standard-Model sector; 
rhovDiag, identity 4900113, a flavour-diagonal 
HV-meson with spin 1 that can decay back into the Standard-Model sector; 
pivUp, identity 4900211, an off-diagonal 
HV-meson with spin 0 that is stable and invisible, with an antiparticle 
pivDn with identity -4900211; the particle is 
the one where the code of the flavour is larger than that of the 
antiflavour; 
rhovUp, identity 4900213, an off-diagonal 
HV-meson with spin 1 that is stable and invisible, with an antiparticle 
rhovDn with identity -4900213; again the particle is 
the one where the code of the flavour is larger than that of the 
antiflavour; 
ggv, identity 4900991, is only rarely used, 
to handle cases where it is kinematically impossible to produce an 
HV-meson on shell, and it therefore is assumed to de-excite by the 
emission of invisible gv-gv  v-glueball bound states. 
 
 
By changing ParticleData, it is possible to allow decays 
also for the off-diagonal Up/Dn mesons, or make either diagonal state 
stable.  Like for Standard Model particles, it is only necessary to 
set the properties of the particle (pivUp, rhovUp), and 
then the ones of the antiparticle (pivDn, rhovDn) are 
mirrored as appropriate. That is, masses and most other properties are 
set the same, while decay channels are inverted. 
 
 
Baryon production is more tricky than meson production, since it depends 
strongly on the choice of the SU(N) gauge group, and since it is 
not so well understood even in our sector. For SU(2), 
where the baryon would consist of two quarks, baryons could be as 
common as mesons. No realistic detailed scenario exists for such a 
setup. In SU(3) we could guess that baryons give of the order 
a 10% correction to the particle production rates, like in our sector, 
and that could be relevant for some phenomenology. For SU(4) 
and higher, where more quarks are needed to form a baryon, one would 
expect a production rate too small to be of any relevance. The current 
handling therefore aims at SU(3) applications. (But if you 
imagine a low production rate of triquarks, with net anticolour, 
then the program will run also for SU(4).) Again, in the 
spirit of simplicity, one baryon is introduced in the default scenario: 
Deltav, identity 4901114, an HV-baryon, assumed to be 
stable. Normally one would expect a spin 1/2 baryon to be the lightest, 
but spin 3/2 here goes together with bookkeeping as if there is only 
one flavour. Mass and decay properties can anyway be selected independent 
of the spin displayed. 
 
Hidden Valley hadrons in an extended setup
 
 
 
The non-default and more detailed handling of HV-hadrons is switched on 
with HiddenValley:separateFlav = on. In it, each 
of the quark and meson flavours are shown explicitly. The quark names 
are qvi, with i an integer in 
the range between 1 and the number of flavours. Similarly, meson names 
are pivij and rhovij, where i = j 
are the flavour-diagonal mesons, else i > j, with 
j representing the antiquark. The identity codes then are 
4900ij1 for pseudoscalars and 4900ij3 for 
vectors. An antimeson comes with an overall negative sign, and here 
i gives the antiquark. 
 
 
You are now free to set masses separately for each quark and meson. 
So as not have to code up the hadronization for alternative 
mass orderings, it is assumed that the quarks are ordered in terms of 
an increasing mass, and specifically that the first quark, 4900101, 
is the lightest one. You are allowed to have some mass-degenerate states, 
of course, and then the ordering between them is irrelevant. As a 
consequence of the quark mass ordering, it is also assumed that the 
lightest hadron is the one with lowest code, 4900111. 
 
 
The data tables by default contain identical properties for all diagonal 
mesons in a multiplet. Currently there is no explicit implementation of 
mixing between them, but the last pseudoscalar meson can be made to 
represent a flavour singlet state eta_1, optionally with a 
reduced production rate. The name remains of the pivii 
type, whatever implicit association you make for this state. More generally, 
it is possible to have both mass-degenerate and non-degenerate scenarios, 
where in either it is useful to be able to set properties of some mesons 
separately. All nondiagonal mesons of a multiplet are also assumed to be 
identical and stable by default, although this can be modified as desired. 
While the separateFlav = on option gives more freedom, it also 
comes with the need for a more detailed setup, with up to 72 different 
meson states that can be given individual properties. (With 8 flavours 
each multiplet has 8 diagonal mesons and 28 off-diagonal mesons. 
The 28 off-diagonal antimesons have properties that follow from the 
respective meson ones.) 
 
 
A corresponding HV-baryon setup for SU(3) would require 
up to 168 spin 1/2 and 120 spin 3/2 states to be specified. As of now, 
this appears to be vast overkill, in particular since these states 
likely are stable. Therefore the separateFlav = on 
option only extends the default model from one to at most eight 
different HV-states, with names Deltavi, and identities 
490i114. That is, we assume there is only one kind of 
diquark being produced, 4901103, at a rate that is the sum of all 
actual diquarks, but represented by the lightest of all these diquarks, 
since this is the one most frequently produced. The use of code 11 should 
not be taken literally; the 4901114 state is not assumed to be produced 
with any different properties than the other seven states just because 
of a seeming identity of all three HV-quarks (as would have been the 
case in a picture with complete baryon multiplets). 
 
 
Some final notes on the separateFlav = on option. 
Firstly, the code is not adapted to allow widely different mass scales 
in the hadronization stage proper, but assume not much worse than the 
Standard Model u/d/s sector. Further states like c/b 
could be produced in the hard process but not during hadronization, 
making use of the probFlav numbers described later. 
Secondly, the Zv by default is set up to couple equally 
to all existing HV-quark states, and also couples to all Standard Model 
particles, while the Fv states are set up to couple only 
to the first HV-quark flavour. You should remember to adjust decay modes 
and branching ratios also for these particles in scenarios where the 
HV-quarks are different. 
 
Further particle properties
 
 
 
Only the spin of the HV-gluon or HV-photon is determined unambiguously 
to be unity, for the others you can make your choice. The emphasis on 
the choice of spinFv, with  spinqv as derived 
from that, comes from the originally studied scenarios in [Car10]. 
In scenarios where a Zv is the main production mechanism 
for qv you must still remember to set spinFv 
even if no Fv are to be produced. Notably, HV-hadron multiplets 
have been defined assuming that qv is spin 1/2, which is also 
the default setup. 
 
mode   HiddenValley:spinFv   
 (default = 0; minimum = 0; maximum = 2)
The spin of the HV partners of the SM fermions, e.g. 
Dv, Uv, Ev and nuEv. 
option  0 : spin 0.   
option  1 : spin 1/2.   
option  2 : spin 1.   
   
 
mode   HiddenValley:spinqv   
 (default = 0; minimum = 0; maximum = 1)
The spin of qv when the Fv (the HV partners of 
the SM fermions) have spin 1/2. (While, if they have spin 0 or 1, 
the qv spin is fixed at 1/2.) 
option  0 : spin 0.   
option  1 : spin 1.   
   
 
parm   HiddenValley:kappa   
 (default = 1.)
If the Fv have spin 1 then their production 
cross section depends on the presence of anomalous magnetic dipole 
moment, i.e. of a kappa different from unity. For other spins 
this parameter is not used. 
   
 
flag   HiddenValley:doKinMix   
 (default = off)
allow kinematic mixing or not. 
   
 
parm   HiddenValley:kinMix   
 (default = 1.)
strength of kinetic mixing. 
   
 
 
You should set the Fv/Zv and qv masses appropriately, 
with the latter smaller than the former two (where relevant) to allow 
decays. When U(1) hadronization is switched on, you need to set 
the gammav mass and decay modes. In this case the qv 
mass is a physical one, since there is no confinement. 
 
 
For SU(N) hadronization instead we need to operate with qv 
constituent masses, and relate these to the HV-meson masses. The simplest 
relation is that 
 
 m_ij = m_i + m_j + K * <sigma_i * sigma_j> / (m_i * m_j) 
 
where m_i, m_j are the constituent quark masses and 
m_ij the meson one. The <sigma_i * sigma_j> 
factor is the spin-spin expectation value, 1 for a vector and -3 for 
a pseudoscalar. Even without knowing the constant K one thus 
can conclude that 
 
m_i + m_j = (3 * m_ij,vector + m_ij, pseudoscalar) / 4 
 
which helps define the HV-quark masses. Note that some parameters, 
like HiddenValley:rFact, should be given nonzero 
values based on a consistent setup of HV quark and HV meson masses. 
Often we also assume that the lightest HV quark has a constituent mass 
below or of the order of Lambda_HV. If this is not the case 
then further thought will be required. The HV-baryon masses should 
suitably be defined approximately as the sum of the the three 
constituent masses for SU(3). Furthermore decay modes also 
need to be set, and lifetimes if you want to have displaced vertices. 
 
 
In the separateFlav = on option the number of properties 
to be set can be very large. Insofar as these still have a somewhat 
regular structure, it may be better to write suitable code to set up 
all the properties rather than typing in a long command file by hand. 
 
 
Production processes
 
 
There are two main HV production modes implemented, either via particles 
charged both under SM and HV groups, or via Z boson coupling to both 
sectors. 
 
flag   HiddenValley:all   
 (default = off)
Common switch for the group of hard Hidden Valley processes, 
as listed separately in the following. The last process is part 
of another scenario and is not affected by this switch. 
   
 
flag   HiddenValley:gg2DvDvbar   
 (default = off)
Pair production g g → Dv Dvbar. 
Code 4901. 
   
 
flag   HiddenValley:gg2UvUvbar   
 (default = off)
Pair production g g → Uv Uvbar. 
Code 4902. 
   
 
flag   HiddenValley:gg2SvSvbar   
 (default = off)
Pair production g g → Sv Svbar. 
Code 4903. 
   
 
flag   HiddenValley:gg2CvCvbar   
 (default = off)
Pair production g g → Cv Cvbar. 
Code 4904. 
   
 
flag   HiddenValley:gg2BvBvbar   
 (default = off)
Pair production g g → Bv Bvbar. 
Code 4905. 
   
 
flag   HiddenValley:gg2TvTvbar   
 (default = off)
Pair production g g → Tv Tvbar. 
Code 4906. 
   
 
flag   HiddenValley:qqbar2DvDvbar   
 (default = off)
Pair production q qbar → Dv Dvbar 
via intermediate gluon. 
Code 4911. 
   
 
flag   HiddenValley:qqbar2UvUvbar   
 (default = off)
Pair production q qbar → Uv Uvbar 
via intermediate gluon. 
Code 4912. 
   
 
flag   HiddenValley:qqbar2SvSvbar   
 (default = off)
Pair production q qbar → Sv Svbar 
via intermediate gluon. 
Code 4913. 
   
 
flag   HiddenValley:qqbar2CvCvbar   
 (default = off)
Pair production q qbar → Cv Cvbar 
via intermediate gluon. 
Code 4914. 
   
 
flag   HiddenValley:qqbar2BvBvbar   
 (default = off)
Pair production q qbar → Bv Bvbar 
via intermediate gluon. 
Code 4915. 
   
 
flag   HiddenValley:qqbar2TvTvbar   
 (default = off)
Pair production q qbar → Tv Tvbar 
via intermediate gluon. 
Code 4916. 
   
 
flag   HiddenValley:ffbar2DvDvbar   
 (default = off)
Pair production f fbar → Dv Dvbar 
via intermediate gamma*/Z^*. 
Code 4921. 
   
 
flag   HiddenValley:ffbar2UvUvbar   
 (default = off)
Pair production f fbar → Uv Uvbar 
via intermediate gamma*/Z^*. 
Code 4922. 
   
 
flag   HiddenValley:ffbar2SvSvbar   
 (default = off)
Pair production f fbar → Sv Svbar 
via intermediate gamma*/Z^*. 
Code 4923. 
   
 
flag   HiddenValley:ffbar2CvCvbar   
 (default = off)
Pair production f fbar → Cv Cvbar 
via intermediate gamma*/Z^*. 
Code 4924. 
   
 
flag   HiddenValley:ffbar2BvBvbar   
 (default = off)
Pair production f fbar → Bv Bvbar 
via intermediate gamma*/Z^*. 
Code 4925. 
   
 
flag   HiddenValley:ffbar2TvTvbar   
 (default = off)
Pair production f fbar → Tv Tvbar 
via intermediate gamma*/Z^*. 
Code 4926. 
   
 
flag   HiddenValley:ffbar2EvEvbar   
 (default = off)
Pair production f fbar → Ev Evbar 
via intermediate gamma*/Z^*. 
Code 4931. 
   
 
flag   HiddenValley:ffbar2nuEvnuEvbar   
 (default = off)
Pair production f fbar → nuEv nuEvbar 
via intermediate gamma*/Z^*. 
Code 4932. 
   
 
flag   HiddenValley:ffbar2MUvMUvbar   
 (default = off)
Pair production f fbar → MUv MUvbar 
via intermediate gamma*/Z^*. 
Code 4933. 
   
 
flag   HiddenValley:ffbar2nuMUvnuMUvbar   
 (default = off)
Pair production f fbar → nuMUv nuMUvbar 
via intermediate gamma*/Z^*. 
Code 4934. 
   
 
flag   HiddenValley:ffbar2TAUvTAUvbar   
 (default = off)
Pair production f fbar → TAUv TAUvbar 
via intermediate gamma*/Z^*. 
Code 4935. 
   
 
flag   HiddenValley:ffbar2nuTAUvnuTAUvbar   
 (default = off)
Pair production f fbar → nuTAUv nuTAUvbar 
via intermediate gamma*/Z^*. 
Code 4936. 
   
 
flag   HiddenValley:ffbar2Zv   
 (default = off)
Production f fbar → Zv where Zv is a generic 
resonance that couples both SM fermion pairs and a qv qvbar 
pair. Not part of the framework of the above processes, but as an 
alternative, that currently is the more popular one. Code 4941. 
   
 
 
Timelike showers
 
 
One key point of this HV scenario is that radiation off the 
HV-charged particles is allowed. This is done by the standard 
final-state showering machinery. (HV particles are not produced 
in initial-state radiation.) All the (anti)particles Fv 
and qv have one (negative) unit of HV charge. That is, 
radiation closely mimics the one in QCD. Both QCD, QED and HV 
radiation are interleaved in one common sequence of decreasing 
emission pT scales. Each radiation kind defines a set of 
dipoles, usually spanned between a radiating parton and its recoil 
partner, such that the invariant mass of the pair is not changed 
when a radiation occurs. This need not follow from trivial colour 
assignments, but is often obvious. For instance,  in a decay 
Qv → q + qv the QCD dipole is between the q and 
the hole after Qv, but qv becomes the recoiler 
should a radiation occur, while the role of q and qv 
is reversed for HV radiation. The selection of recoilers in subsequent 
emissions is regulated by the TimeShower:recoilToColoured 
switch within the QCD and HV sectors separately. 
 
This also includes matrix-element corrections to the 
first/hardest HV emission for a number 
of decay processes, with colour, spin and mass effects included 
[Nor01]. They were calculated within the context of the 
particle content of the MSSM, however, which does not include spin 1 
particles with unit colour charge. In such cases spin 0 is assumed 
instead. By experience, the main effects come from mass and colour 
flow anyway, so this is not a bad approximation. (Furthermore the 
MSSM formulae allow for gamma_5 factors from wave 
functions or vertices; these are even less important.) There are some 
processes where no corrections at all are included currently, notably 
for gammav emission in an Qv → q + qv decay. 
In such cases hard emissions are likely to be overestimated, 
but by experience not by a big amount. 
 
An emitted gv can branch in its turn, 
gv → gv + gv. This radiation may affect momenta 
in the visible sector by recoil effect, but this is a minor 
effect relative to the primary emission of the gv. 
 
While the default model has a fixed Hidden Valley coupling 
 alpha_HV, some further work [Scw15] has considered 
the impact of a running coupling. This is included as options at 
the one-, two- and three-loop level. Beta functions up three-loop 
and definitions of higher-order Lambda follow [Rit97], 
[Yao06] and [Pro07]. The running is handled by the 
AlphaSUN class, for lack of better alternatives put in 
the StandardModel.h and StandardModel.cc files, 
and are documented on the 
Standard-Model Parameters 
page. 
 
flag   HiddenValley:FSR   
 (default = off)
switch on final-state shower of gv or gammav 
in a HV production process. 
   
 
mode   HiddenValley:alphaOrder   
 (default = 0; minimum = 0; maximum = 3)
Order at which alpha_HV runs. This switch has no function for 
the U(1) case, where alpha_HV is always fixed, but only 
for the SU(N) ones. For a running alpha_HV it is 
possible either to set the alpha_HV value at a reference scale 
or to set a Lambda_HV scale, see further the next four entries. 
option  0 : zeroth order, i.e. alpha_HV is kept 
fixed at the value alphaFSR below.   
option  1 : first order, with the beta function based 
on Ngauge and Nflav.    
option  2 : second order, with the beta function based 
on Ngauge and Nflav.    
option  3 : third order, with the beta function based 
on Ngauge and Nflav.    
   
 
parm   HiddenValley:alphaFSR   
 (default = 0.1; minimum = 0.0)
The alpha_HV coupling strength of gv/gammav emissions. 
When HiddenValley:alphaOrder = 0, or for a U(1) 
scenario, this value is fixed. For an SU(N) model with 
alphaOrder above zero, i.e. when alpha_HV 
runs, it is the value at the reference scale below. It corresponds to 
alpha_strong of QCD or alpha_em of QED. For shower 
branchings such as Dv → Dv + gv the coupling is multiplied 
by C_F = (N^2 - 1) / (2 * N) for an SU(N) group and 
for gv → gv + gv by N. 
   
 
parm   HiddenValley:alphaFSRrefScale   
 (default = 91.188; minimum = 0.0)
A reference scale, where the HiddenValley:alphaFSR value 
above is defined, in case of a running coupling. Default value is the 
Z^0 mass, by analogy with QCD, but it can be picked to 
whatever is convenient. If the HV model resembles the QCD sector, 
but with masses scaled up by some factor, then it would make sense to 
increase the reference scale accordingly. 
   
 
flag   HiddenValley:setLambda   
 (default = off)
By default an HiddenValley:alphaFSR value is defined 
at a reference scale, as outlined above, and then converted to a 
Lambda_HV scale for usage in the relevant running-coupling 
expressions. If setLambda is on, instead the 
Lambda_HV value can be set directly below. 
   
 
parm   HiddenValley:Lambda   
 (default = 0.4; minimum = 0.01)
the Lambda_HV parameter used for the case of a running 
alpha_HV(Q^2) when HiddenValley:setLambda = on. 
This Lambda_HV is used in the respective one-, two- or 
three-loop alpha_HV(Q^2) expression, depending on 
HiddenValley:alphaOrder. This perturbative Lambda 
value is not to be confused with the nonperturbative Lambda 
defined in the hadronization section below, although the two ought 
to be of the same order of magnitude. 
   
 
parm   HiddenValley:pTminFSR   
 (default = 0.44; minimum = 0.1)
lowest allowed pT of emission. Should be greater than 
or equal to 1.1 times Lambda, or it will be reset 
automatically. 
   
 
 
Hadronization
 
 
By default the HV particles with no Standard Model couplings 
are not visible. Their presence can only be deduced by the 
observation of missing (transverse) momentum in the event as a 
whole. In the current implementation it is possible to simulate 
two different scenarios where activity can leak back from the 
hidden sector. 
 
 
The first possibility is relevant for the U(1) scenario. 
The U(1) group may be broken, so that the gammav 
acquires a mass. Furthermore, the gammav may have a 
small mixing angle with the normal photon, or with some Z' 
state or other mediator, and may thus decay back into Standard 
Model particles. The qv still escapes undetected; 
recall that there is no confinement in the U(1) option. 
 
 
In order to enable this machinery two commands are necessary, 
4900022:m0 = ... to set the  gammav mass 
to the desired value, and 4900022:onMode = on to enable 
gammav decays. The default gammav decay 
table contains all Standard Model fermion-antifermion pairs, 
except top, with branching ratios in proportion to their coupling 
to the photon, whenever the production channel is allowed by 
kinematics. This table could easily be tailored to more specific 
models and needs. For instance, for a mass below 1 - 2 GeV, it 
would make sense to construct a table of exclusive hadronic decay 
channels rather than go the way via a hadronizing quark pair. 
 
 
The gammav are expected to decay so rapidly that no 
secondary vertex will be detectable. However, it is possible to 
set 4900022:tau0 to a finite lifetime (in mm) that 
will be used to create separated secondary vertices. 
 
 
The second, more interesting, possibility is relevant for the 
SU(N) scenarios. Here the gauge group remains unbroken, i.e. 
gv is massless, and the partons are confined. Like in 
QCD, the HV-partons can therefore be arranged in one single 
HV colour-ordered chain, with a qv in one end, a 
qvbar in the other, and a varying number of 
gv in between. Each event will only contain (at most) 
one such string, (i) since perturbative branchings 
gv → qv qvbar have been neglected, as is a reasonable 
approximation for QCD, and (ii) since HV colours are assigned in the 
N_C → infinity limit, just like in the handling of 
string fragmentation in QCD. The HV-string can then fragment by the 
nonperturbative creation of qv qvbar pairs, leading to 
the formation of HV-mesons along the string, each with its 
qv from one vertex and its qvbar from 
the neighbouring one. 
 
 
Since, to begin with, we have only assumed there to be one qv 
species, all produced qv qvbar HV-mesons are of the 
same flavour-diagonal species. Such an HV-meson can decay back to 
the normal sector, typically by whatever mediator particle allowed 
production in the first place. In this framework the full energy put 
into the HV sector will leak back to the normal one. To allow more 
flexibility, a possibility of n_Flav different 
qv species is introduced. By default they are all assumed 
to have the same mass and other properties, but distinguished by 
some flavour-like property. Only the flavour-diagonal ones can decay, 
meaning that only a fraction (approximately) 1/n_Flav of the 
HV-energy leaks back, while the rest remains in the hidden sector. 
A more differential description of all the states can be set up 
for the HiddenValley:separateFlav = on option, as 
already noted. 
 
 
This scenario contains more parameters than the first one, for the 
U(1) group. They can be subdivided into two sets. One is 
related to particle properties, both for qv and for the 
two different kinds of HV-mesons, here labeled 4900111 and 4900113 
for the diagonal ones, and +-4900211 and +-4900213 for the 
off-diagonal ones, plus optionally an 4901114 baryon. The extension 
to more than two HV-quark species is trivial. Furthermore the 
hvMesonDiag decay modes need to be set up. Like with the 
gammav in the U(1) option, the default 
rhovDiag decay table is based on the branching ratios 
of an off-shell photon, while the ones of the pivDiag 
are assumed proportional to the squared mass, times a (HV-)colour 
factor of 3 where relevant. 
 
 
The second set are fragmentation parameters that extend or replace 
the ones used in normal string fragmentation. Some of them are not 
necessarily encoded straight off, however, but rather set to scale 
with changed quark and hadron masses or with the nonperturbative 
Lambda value, so as to keep a sensible default behaviour. 
For QCD-like theories, the two 
are approximately related by Lambda = 0.4 * m(rho) according 
to lattice QCD calculations (we thank Matt Strassler for persistently 
pointing this out). Here rho is the lightest spin-1 
meson, assumed to be made out of light quarks, with bare masses 
below the respective Lambda scale. This scaling assumption 
is chosen as the default because it is simple and will give reasonable 
answers across a wide range of models. If precision is needed, 
however, Lambda should be set more carefully by the user. 
Based on the above assumption, the definition 
 
  k = Lambda_HV / Lambda_QCD = m(rho_HV) / m(rho_QCD) 
 
offers two alternative ways to define a rescaling factor for some 
of the fragmentation parameters. Notably, the b parameter 
below occurs in the dimensionless combination bm^2, 
suggesting a scaling of b by a factor 1 / k^2 
when m is scaled by k. Similarly, the sigma 
parameter occurs in the dimensionless combination pT/sigma, 
so here the sigma scale factor should rather be k. 
Scaling would imply that, if particle masses and the subsystem energy 
are scaled up (or down) by a common factor (like the k above), 
then so are the longitudinal and transverse momentum spectra of (HV) 
hadrons, with a constant average number of hadrons. 
 
 
The fragmentation parameters are as follows. 
 
flag   HiddenValley:fragment   
 (default = off)
switch on string fragmentation of the HV partonic system. 
Only relevant for SU(N) scenarios. 
   
 
mode   HiddenValley:nFlav   
 (default = 1; minimum = 1; maximum = 8)
number of different flavours assumed to exist in the hadronization 
description, leading to approximately 1/n_Flav of the 
produced HV-mesons being flavour-diagonal and capable to decay back 
to Standard Model particles. 
   
 
flag   HiddenValley:separateFlav   
 (default = off)
By the choice of nFlav above, a wide set of HV-mesons 
are implied, and in principle all of their properties have to be 
set separately. For the default off option it is assumed 
that the dividing line goes between mesons with on- or off-diagonal 
flavour content. Thus only four separate mesons need be defined 
pivDiag, rhovDiag, pivUp/pivDn, rhovUp/rhovDn, 
plus optionally a Deltav baryon, which greatly simplifies 
the task of defining masses, decay modes, and branching ratios. 
   
 
parm   HiddenValley:probDiquark   
 (default = 0.; minimum = 0.; maximum = 1.)
probability that the string breaks by "diquark-antidiquark" production 
rather than quark-antiquark one. This then leads to an adjacent 
baryon-antibaryon pair in the flavour chain. Currently only one kind 
of diquark is implemented, implying at most eight different baryons 
if separateFlav = on, else only one. The value should be 
in the ballpark of 0.1 for SU(3), but should be kept at zero 
for bigger gauge groups. It cannot be trusted for SU(2), 
so it may be better to keep it zero there as well. 
   
 
pvec   HiddenValley:probFlav   
 (default = {1.,1.,1.,1.,1.,1.,1.,1.}; minimum = 0.; maximum = 1.)
production suppression at a string break for either of the 
nFlav different flavour-antiflavour possibilities that 
are allowed. Corresponds to the exp(-pi * m_q^2 / kappa) 
tunneling suppression factor used in normal string fragmentation 
to explain why s quarks are less frequently produced than 
u,d ones. When nFlav is less than 8 the trailing 
positions are not used, but they should still be set to ensure 
consistent handling. 
   
 
parm   HiddenValley:probVector   
 (default = 0.75; minimum = 0.; maximum = 1.)
fraction of HV-mesons that are assigned spin 1 (vector), with the 
remainder spin 0 (pseudoscalar). Assuming the qv have 
spin 1/2 and the mass splitting is small, spin counting 
predicts that 3/4 of the mesons should have spin 1. 
   
 
parm   HiddenValley:probKeepEta1   
 (default = 1.0; minimum = 0.; maximum = 1.)
multiplicative factor suppressing the production rate of the diagonal 
pseudoscalar meson with the largest code, for now assumed to be the 
eta_1 flavour-singlet state of the multiplet. 
   
 
mode   HiddenValley:setabsigma   
 (default = 0; minimum = 0; maximum = 2)
set the fragmentation parameters, with options arranged in order of 
increasing user control. The parameters affected are 
aV = HiddenValley:aLund, 
bV = HiddenValley:bLund, and 
sigmaV = HiddenValley:sigmaLund. 
option  0 : the above-mentioned relation between the 
nonperturbative Lambda confinement scale and the lightest 
vector meson mass, both in the QCD (the rho = rho_QCD meson) 
and in the HV sector (call it rho_HV), is assumed valid. 
The ratio k = m(rho_HV) / m(rho_QCD) is then used 
to rescale the standard QCD values as bV = bQCD / k^2 
and sigmaV = k * sigmaQCD, while the aV value 
remains as in QCD.   
option  1 : the nonperturbative Lambda confinement 
scales are set by the user in HiddenValley:LambdaNPHV and 
HiddenValley:LambdaNPQCD for the HV and QCD sectors, 
respectively. From these two values the ratio 
k = Lambda_NP_HV / Lambda_NP_QCD is obtained and the 
fragmentation parameters are set, rescaled from the standard values 
as for option 0 above.   
option  2 : full user control to set the three values for 
aV, bV and sigmaV below. 
It is especially important to ensure that bV and 
sigmaV obtain properly rescaled values, as discussed above, 
but with the possibility to deviate from a simple rescaling, e.g. 
to define an "error band" for predictions.    
   
 
parm   HiddenValley:LambdaNPQCD   
 (default = 0.31; minimum = 0.0)
the nonperturbative Lambda_QCD scale, by default taken to 
be approximately 0.4 times the rho^0 mass. Used in the 
HiddenValley:setabsigma = 1 option above. Not to be 
confused with the Lambda value(s) of the perturbative QCD 
description, although the two should not be too far apart. 
   
 
parm   HiddenValley:LambdaNPHV   
 (default = 0.31; minimum = 0.0)
the nonperturbative Lambda_HV scale, for the user to set 
in the HiddenValley:setabsigma = 1 option, as described 
above. The prescription of 0.4 times the lightest vector meson mass 
might offer some guidance for QCD-like theories. If the model 
studied does not have any close equivalent to the SM u and d quarks, 
in terms of being well below Lambda_HV in bare mass, it could 
be useful to estimate what the rho mass would have been, 
had such equivalents existed. This parameter is set separately 
from the Lambda scale used in the HV parton-shower description, 
although it would make sense for the two to be closely related. 
   
 
parm   HiddenValley:aLund   
 (default = 0.68; minimum = 0.0; maximum = 2.0)
the dimensionless a parameter of the Lund symmetric 
fragmentation function. See the normal 
string fragmentation description 
for the shape of this function. For 
HiddenValley:setabsigma = 0 or 1, the PYTHIA code will 
read in and use the value of StringZ:aLund. 
It is only for HiddenValley:setabsigma = 2 that 
HiddenValley:aLund is used, and therefore meaningfully 
can be set by the user. 
Note: The default value has been changed as of PYTHIA 
8.313, to agree with the Monash tune value. 
   
 
parm   HiddenValley:bLund   
 (default = 0.98; minimum = 0.)
The b parameter of the Lund symmetric fragmentation function, 
with dimensions GeV^{-2}. See the normal 
string fragmentation 
description for the shape of this function. For 
HiddenValley:setabsigma = 0 or 1, the PYTHIA code will 
read in and use the value StringZ:bLund, 
rescaled by the factor 1 / k^2 introduced above. It is only 
for HiddenValley:setabsigma = 2 that 
HiddenValley:bLund is used, and therefore 
meaningfully can be set by the user. Then it is important to remember 
that its value should be rescaled approximately by a factor 
1 / k^2 from its default. 
Note: As of PYTHIA 8.313, this parameter replaces 
the previous HiddenValley:bmqv2, which was dimensionless 
by its multiplication with a squared HV quark mass. This could work for 
simple HV quark and meson mass setups, but was confusing for richer 
spectra. The default value was also off from what it should have been 
for good scaling of the fragmentation function shape. It is possible 
to reproduce the old behaviour within the 
HiddenValley:setabsigma = 2 option. 
   
 
parm   HiddenValley:sigmaLund   
 (default = 0.335; minimum = 0.0)
the width sigma of transverse momenta in the HV fragmentation 
process, with dimensions GeV. See the 
string fragmentation page for 
further details. For HiddenValley:setabsigma = 0 or 1, 
the PYTHIA code will read in and use the value 
StringPT:sigma, which is rescaled by the factor k 
introduced above. It is only for HiddenValley:setabsigma = 2 
that HiddenValley:sigmaLund is used, and therefore 
meaningfully can be set by the user. Then it is important to remember 
that its value should be rescaled approximately by a factor 
k from its default. 
Note: As of PYTHIA 8.313, this parameter replaces 
the previous HiddenValley:sigmamqv, which was dimensionless 
by its division with a HV quark mass. Again it is possible to 
reproduce the old behaviour within the 
HiddenValley:setabsigma = 2 option. 
   
 
pvec   HiddenValley:rFact   
 (default = {0.,0.,0.,0.,0.,0.,0.,0.}; minimum = 0.; maximum = 2.)
the Bowler correction factor to the Lund symmetric fragmentation 
function, see the StringZ:rFact parameters on the 
string fragmentation page. 
Should be 0 for light quarks, like the u/d/s ones in the SM, 
but around 1 for for heavy quarks, like the c/b ones. 
Typically the lighter ones are those assumed to be produced in string 
breakups, i.e. those with nonvanishing values in 
HiddenValley:probFlav, while the heavy ones are only 
produced at the endpoints of the string, from the perturbative process. 
(Unless all quarks are heavy, i.e. much above the Lambda 
scale, but then the fragmentation framework is skating on thin ice.) 
Note that these parameters can (and should when relevant) be set 
irrespective of the  HiddenValley:setabsigma value. 
Note: As of PYTHIA 8.313, this vector supersedes 
HiddenValley:rfactqv, which only offered one common value 
for all HV quarks. The default value has also been changed from 1 to 
0, to be in line with a HV sector of light quarks. 
   
 
 
Event information
 
 
For the SU(N) QCD-like scenarios, also the related HV colours 
are bookkept. The normal colour tag locations cannot be reused, 
since some particles carry both normal and HV colours. 
Instead a small vector is located in the Event class, 
where the HV colour tags can be stored for HV-coloured particles only. 
This information can be accessed for each particle, see the 
Particle Properties page, 
the Particle::colHV/acolHV/colsHV methods. 
As a complement to the normal event record, the 
Event::listHVcols() method lists the particles 
that have HV colours and which colour tags those carry; see 
the Event Record page. 
Also some other methods are found there.