phasespace

class ChainGenerator(m0, mi)

Bases: object

struct = m0 -> [m1, m2, m3] # (m0, [m1, m2, m3]) m0 -> float mi -> float | struct

cal_max_weight()

generate(N)

get_gen(idx_gen)

class PhaseSpaceGenerator(m0, mass)

Bases: object

Phase Space Generator for n-body decay

cal_max_weight()

flatten_mass(ms, importances=True)

sampling from mass with weight

generate(n_iter: int, force=True, flatten=True, importances=True) → list

generate n_iter events

Parameters

• n_iter – number of events

• force – switch for cutting generated data to required size

• flatten – switch for sampling with weights

Returns

daughters 4-momentum, list of ndarray with shape (n_iter, 4)

generate_mass(n_iter)

generate possible inner mass.

generate_momentum(mass, n_iter=None)

generate random momentum from mass, boost them to a same rest frame

generate_momentum_i(m0, m1, m2, n_iter, p_list=[])

\(|p|\) = m0,m1,m2 in m0 rest frame :param p_list: extra list for momentum need to boost

get_mass_range()

get_weight(ms, importances=True)

calculate weight of mass

\[w = \frac{1}{w_{max}} \frac{1}{M}\prod_{i=0}^{n-2} q(M_i,M_{i+1},m_{i+1})\]

mass_importances(mass)

generate possible inner mass.

set_decay(m0, mass)

set decay mass, calculate max weight

\[w_{max} = \frac{1}{M}\prod_{i=0}^{n-2} q(max(M_i),min(M_{i+1}),m_{i+1})\]

\[max(M_i) = M_0 - \sum_{j=1}^{i} (m_j)\]

\[min(M_i) = \sum_{j=i}^{n} (m_j)\]

class UniformGenerator(a, b)

Bases: object

generate(N)

generate_phsp(m0, mi, N=1000)

general method to generate decay chain phase sapce >>> (a, b), c = generate_phsp(1.0, ( … (0.3, (0.1, 0.1)), … 0.2), … N = 10) >>> assert np.allclose(LorentzVector.M(a+b+c), 1.0)

get_p(M, ma, mb)