Phase Space Layout

CoordinateMap{P,M,PSL}(proc::P, model::M, psl::PSL)

A CoordinateMap represents a transformation that maps phase space coordinates to particle momenta for a specific scattering process. This type encapsulates the scattering process definition (proc), the physics model (model), and the phase space layout (psl). The CoordinateMap is callable and supports the conversion of both incoming and outgoing phase space coordinates into four-momenta.

Fields

• proc: The scattering process definition, subtype of AbstractProcessDefinition.
• model: The physics model, subtype of AbstractModelDefinition.
• psl: The phase space layout, either incoming or outgoing, that maps coordinates to momenta.

Usage

Incoming Coordinates

The CoordinateMap can be called with a tuple of incoming phase space coordinates (in_coords), which are used to compute the corresponding incoming particle four-momenta. This is done by calling the phase space construction function QEDbase.build_momenta using the proc, model, and psl provided in the CoordinateMap.

# Create a coordinate map for in phase space
in_coord_map = CoordinateMap(proc, model, in_psl)

# call on in-coordinates to build the momenta
in_coord_map(in_coords)

• Arguments:

  • in_coords: A tuple of phase space coordinates for the incoming particles.

• Returns: A tuple of four-momenta corresponding to the incoming particles.

Incoming and Outgoing Coordinates

The CoordinateMap can also be called with both incoming (in_coords) and outgoing (out_coords) phase space coordinates. The incoming momenta are computed first, and then the total momentum (Ptot) is calculated by summing these momenta. This total momentum is then used to compute the outgoing particle four-momenta using the provided outgoing phase space layout.

# Create a coordinate map for out phase space
coord_map = CoordinateMap(proc, model, out_psl)

# call on in- and out-coordinates to build the momenta
coord_map(in_coords, out_coords)

• Arguments:

  • in_coords: A tuple of phase space coordinates for the incoming particles.
  • out_coords: A tuple of phase space coordinates for the outgoing particles.

• Returns:

  • A tuple where the first element is the incoming particle momenta and the second element is the outgoing particle momenta, both represented as tuples of four-momenta.

Notes

• The CoordinateMap provides a flexible mechanism for transforming phase space coordinates into physically meaningful four-momenta, ensuring consistency with the scattering process, physics model, and phase space layout.
• The type is designed to handle both incoming and outgoing momenta, ensuring proper energy and momentum conservation for the process.

CoordinateMapCached{P,M,PSL,TM}(proc::P, model::M, psl::PSL, in_moms::TM)

A CoordinateMapCached represents a precomputed transformation for phase space coordinates, where the momenta of the incoming particles are cached. This can improve performance in cases where the incoming momenta remain constant and only the outgoing momenta need to be computed based on new coordinates.

The cached map encapsulates the scattering process (proc), the physics model (model), the phase space layout (psl), and the precomputed incoming momenta (in_moms).

Fields

• proc: The scattering process definition, which defines the incoming and outgoing particles.
• model: The physics model, which governs the interaction type and momentum distributions.
• psl: The phase space layout, either incoming or outgoing, that maps coordinates to momenta.
• in_moms: A collection of precomputed four-momenta for the incoming particles, usually a Tuple.

Usage

Cached Incoming Coordinates

When a CoordinateMapCached build with psl::AbstractInPhaseSpaceLayout is called without any arguments, it returns the precomputed incoming momenta (in_moms) directly. This provides an efficient way to access the incoming particle momenta that have already been calculated and stored in the map.

# Create a coordinate map for in phase space
in_coord_map = CoordinateMapCached(proc, model, in_psl, in_moms)

# call to return the in-momenta
in_coord_map()

• Returns: The cached tuple of four-momenta for the incoming particles.

Outgoing Coordinates

The CoordinateMapCached can be called with outgoing phase space coordinates (out_coords). The cached incoming momenta (in_moms) are used to compute the total momentum (Ptot), which is then passed along with the outgoing coordinates to compute the momenta of the outgoing particles.

# Create a coordinate map for out phase space
out_coord_map = CoordinateMapCached(proc, model, out_psl, in_moms)

# call on out coordinates to return the out-momenta
out_coord_map(out_coords)

• Arguments:

  • out_coords: A tuple of phase space coordinates for the outgoing particles.

• Returns:

  • A tuple of four-momenta for the outgoing particles, consistent with the total momentum derived from the cached incoming momenta.

Notes

• Caching: The CoordinateMapCached is useful when the incoming momenta are fixed or do not change frequently, as it avoids recomputation by storing the incoming momenta in the cache.
• Efficiency: This caching mechanism can significantly enhance performance when repeatedly evaluating the scattering process with fixed incoming particles but varying outgoing configurations.
• The type is designed to handle both incoming and outgoing momenta, ensuring proper energy and momentum conservation for the process.

AbstractTwoBodyInPhaseSpaceLayout <: AbstractInPhaseSpaceLayout

An abstract type representing an incoming phase space layout specifically designed for two-body systems in high-energy physics. This type is a specialized subtype of AbstractInPhaseSpaceLayout, focusing on scenarios where two particles are incoming and participate in a scattering or decay process.

Concrete subtypes of AbstractTwoBodyInPhaseSpaceLayout define the parameterization of the momenta of the two incoming particles, such as by Energy, Rapidity, or other kinematic coordinates. These layouts allow for consistent calculation of the system's phase-space properties under conservation laws, facilitating method dispatch in functions like QEDbase._build_momenta.

This type serves as a foundation for implementing concrete layouts, ensuring that two-body processes can be modeled flexibly and accurately within phase space calculations.

See Also

• QEDbase.AbstractInPhaseSpaceLayout: A broader type for general incoming phase space layouts.
• AbstractTwoBodyRestSystem: A subtype representing two-body systems where one particle is at rest.

AbstractTwoBodyRestSystem <: AbstractTwoBodyInPhaseSpaceLayout

An abstract type representing the phase space layout of a two-body system in which one particle is at rest in the system's frame.

Concrete subtypes of AbstractTwoBodyRestSystem typically specify the coordinate system used to parameterize the momentum of the non-resting particle, such as Energy, SpatialMagnitude, CenterOfMomentumEnergy, or Rapidity. The choice of coordinate system impacts how the momenta of the incoming particles are constructed.

This type serves as a base for defining custom layouts that rely on rest-frame assumptions for two-body scattering or decay processes, and it facilitates method dispatch in momentum construction functions like QEDbase._build_momenta.

See Also

• TwoBodyRestSystem: A concrete implementation of AbstractTwoBodyRestSystem that supports various univariate coordinates for describing the non-resting particle.

TwoBodyRestSystem{RESTIDX, COORD<:AbstractUnivariateCoordinate}

Represents a two-body scattering system in the rest frame of one of the particles, where one particle (identified by RESTIDX) is at rest and the other particle's momentum is described by a coordinate system COORD. The system uses various univariate coordinates, such as energy, rapidity, or center-of-momentum energy, to parameterize the momentum of the moving particle.

This type allows for easy construction of the incoming particle momenta using the phase space layout for two-body systems, commonly used in high-energy physics processes. The system supports different coordinate systems for defining the moving particle's momenta, including energy-based and rapidity-based layouts.

Fields

• coord::COORD: The coordinate type (COORD) used to describe the non-resting particle's momenta.

Supported Coordinates

• Energy: Defines the energy of the moving particle.
• SpatialMagnitude: Defines the spatial momentum magnitude of the moving particle.
• CMSEnergy: Defines the total center-of-mass energy of the system.
• Rapidity: Defines the rapidity of the moving particle.

Example Usages

The following examples show how to use different coordinate systems with TwoBodyRestSystem in conjunction with the _build_momenta interface.

Example 1: Using Energy Coordinate

psl = TwoBodyRestSystem(Energy(2))  # Particle 1 at rest, particle 2 described by its energy
in_coords = (100.0,)  # Energy of particle 2
momenta = build_momenta(proc, model, psl, in_coords)

This constructs the momenta assuming particle 1 is at rest, and particle 2 has an energy of 100 GeV.

Example 2: Using SpatialMagnitude Coordinate

psl = TwoBodyRestSystem(SpatialMagnitude(2))  # Particle 1 at rest, particle 2 described by its spatial magnitude
in_coords = (50.0,)  # Spatial momentum magnitude of particle 2
momenta = build_momenta(proc, model, psl, in_coords)

In this case, the moving particle's spatial momentum magnitude is given, and its energy is calculated based on its mass.

Example 3: Using CMSEnergy Coordinate

psl = TwoBodyRestSystem(1,CMSEnergy())  # Particle 1 at rest, particle 2 described by the center-of-mass energy
in_coords = (200.0,)  # Total center-of-mass energy of the system
momenta = build_momenta(proc, model, psl, in_coords)

Here, the center-of-mass energy of the system is provided, and the momenta of both particles are calculated while conserving energy and momentum.

Example 4: Using Rapidity Coordinate

psl = TwoBodyRestSystem(Rapidity(2))  # Particle 1 at rest, particle 2 described by its rapidity
in_coords = (1.0,)  # Rapidity of particle 2
momenta = _build_momenta(proc, model, psl, in_coords)
@assert isapprox(getMass(sum(momenta)),50.0)

In this case, the rapidity of particle 2 is given, and its energy and momentum are computed based on this parameter.

Notes

• RESTIDX is the index of the particle that is at rest in the system.
• COORD specifies the coordinate type of the non-resting particle and must be a subtype of AbstractUnivariateCoordinate.
• The coordinate system should be compatible with the given particles and their masses, otherwise, an error may occur during momentum construction.

Throws

• ArgumentError if invalid coordinates are used (e.g., unsupported coordinate types or incompatible indices).