### Energy and Angular Measures

The appropriate notions of energy and angle depend on the collider context.
Typically, one wants to work with observables that respect the appropriate
Lorentz subgroup for the collision type of interest. EnergyFlow is capable of
handling two broad classes of measures: $e^+e^-$ and hadronic, which are
selected using the required `measure`

argument. For substructure applications,
it is often convenient to normalize the energies so that $\sum_iz_i=1$. The
`normed`

keyword argument is provided to control normalization of the energies
(default is `True`

).

Each measure comes with a parameter $\beta>0$ which controls the relative
weighting between smaller and larger anglular structures. This can be set using
the `beta`

keyword argument (default is `1`

). There is also a $\kappa$
parameter to control the relative weighting between soft and hard energies.
This can be set using the `kappa`

keyword argument (default is `1`

). Only
`kappa=1`

yields collinear-safe observables.

Beyond the measures implemented here, the user can implement their own custom measure by passing in ${z_i}$ and ${\theta_{ij}}$ directly to the EFP classes.

#### Hadronic Measures

For hadronic collisions, observables are typically desired to be invariant under boosts along the beam direction and rotations about the beam direction. Thus, particle transverse momentum $p_T$ and rapidity-azimuth coordinates $(y,\phi)$ are used.

There are two hadronic measures implemented in EnergyFlow: `'hadr'`

and
`'hadrdot'`

. These are listed explicitly below.

`'hadr'`

:

`'hadrdot'`

:

*e+e-* Measures

For $e^+e^-$ collisions, observables are typically desired to be invariant under the full group of rotations about the interaction point. Since the center of momentum energy is known, the particle energy $E$ is typically used. For the angular measure, pairwise Lorentz contractions of the normalized particle four-momenta are used.

There is one $e^+e^-$ measure implemented.

`'ee'`

:

### Measure

Class for dealing with any kind of measure.

```
energyflow.Measure(measure, beta=1, kappa=1, normed=True, coords=None, check_input=True)
```

Processes inputs according to the measure choice.

**Arguments**

**measure**:*string*- The string specifying the energy and angular measures to use.

**beta**:*float*- The angular weighting exponent $\beta$. Must be positive.

**kappa**: {*float*,`'pf'`

}- If a number, the energy weighting exponent $\kappa$. If
`'pf'`

, use $\kappa=v$ where $v$ is the valency of the vertex.`'pf'`

cannot be used with measure`'hadr'`

. Only IRC-safe for`kappa=1`

.

- If a number, the energy weighting exponent $\kappa$. If
**normed**: bool- Whether or not to use normalized energies.

**coords**: {`'ptyphim'`

,`'epxpypz'`

,`None`

}- Controls which coordinates are assumed for the input. If
`'ptyphim'`

, the fourth column (the masses) is optional and massless particles are assumed if it is not present. If`None`

, coords with be`'ptyphim'`

if using a hadronic measure and`'epxpypz'`

if using the e+e- measure.

- Controls which coordinates are assumed for the input. If
**check_input**: bool- Whether to check the type of input each time or assume the first input type.

#### evaluate

```
evaluate(arg)
```

Evaluate the measure on a set of particles.

**Arguments**

**arg**:*2-d numpy.ndarray*- A two-dimensional array of the particles with each row being a
particle and the columns specified by the
`coords`

attribute.

- A two-dimensional array of the particles with each row being a
particle and the columns specified by the

**Returns**

- (
*1-d numpy.ndarray*,*2-d numpy.ndarray*)- (
`zs`

,`thetas`

) where`zs`

is a vector of the energy fractions for each particle and`thetas`

is the distance matrix between the particles.

- (