## Hidden Valley Processes

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 `Fragmentation:model = 1` (thermal fragmentation) 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 4900`ij`1 for pseudoscalars and 4900`ij`3 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 490`i`114. 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 HV 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. Note the difference relative to `StringFlav:mesonUDvector` and related ones, which set the ratio V/PS, whereas here V/(V+PS) is set.

`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.

In PYTHIA there are also a few more fragmentation parameters and constants that are defined with our QCD world in mind. Largely this poses no problem for HV scenarios with mass scales above the QCD one, but would preclude studies with HV scales significantly below QCD ditto. To this end, a rescaling has been introduced for them in the HV option, so that the QCD values can be kept unchanged. The rescaling factor is the k = m(rho_HV) / m(rho_QCD) already introduced above. Included in this rescaling are the input parameters `FragmentationSystems:mJoin`, (`FragmentationSystems:mJoinJunction`, but not used currently), `HadronLevel:mStringMin`, and `StringFragmentation:stopMass`. Local rescaled parameters are also defined from the constants `ColConfig::CONSTITUENTMASS`, `StringRegion::MJOIN`, `StringEnd::TINY`, `StringEnd::PT2SAME`, and `StringFragmentation::CLOSEDM2MAX`.

### 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.