lips.particle

class lips.particle.Particle(kinematics=None, real_momentum=False, field=Field('mpc', 0, 300))

Describes the kinematics of a single particle.

angles_for_squares()

Flips left and right spinors.

comp_twist_x(other)

property four_mom

Four Momentum with upper index: P^μ

property four_mom_d

Four Momentum with lower index: P_μ

property l_sp_d

Left spinor with index down: λ̅_α̇ (row vector).

property l_sp_u

Left spinor with index up: λ̅^α̇ (column vector).

lsq()

Lorentz dot product with itself: 2 trace(P^{α̇α}P̅̅_{αα̇}) = P^μ * η_μν * P^ν.

property m

property m2

property r2_sp

Four Momentum Slashed with upper indices: P^{α̇α}

property r2_sp_b

Four Momentum Slashed with lower indices: P̅̅_{αα̇}

property r_sp_d

Right spinor with index down: λ_α (column vector).

property r_sp_u

Right spinor with index up: λ^α (row vector).

randomise(real_momentum=False)

randomise_finite_field()

randomise_mpc(real_momentum=False)

Randomises its momentum.

randomise_padic()

randomise_rational()

randomise_twist()

property spinors_are_in_field_extension

twist_x_to_mom(other)

lips.particles

class lips.particles.Particles(number_of_particles_or_particles=None, seed=None, real_momenta=False, field=Field('mpc', 0, 300), fix_mom_cons=True, internal_masses=None)

Describes the kinematics of n particles. Base one list of Particle objects.

analytical_subs_d()

angles_for_squares()

Switches all angle brackets for square brackets and viceversa.

static check_consistency(temp_string)

cluster(llIntegers, massive_fermions=None)

Returns clustered particle objects according to lists of lists of integers (e.g. corners of one loop diagram). Massive legs are by default massive scalars. Massive fermions can be specificed as e.g.: massive_fermions=((3, ‘u’, all), (4, ‘d’, all)))

copy()

Return a shallow copy of the list.

fix_mom_cons(A=0, B=0, real_momenta=False, axis=1)

Fixes momentum conservation using particles A and B.

four_momenta_for_mathematica(as_spinors=False)

ijk_to_3Ks(ijk)

ijk_to_3NonOverlappingLists(ijk, mode=1)

image(permutation_or_rule)

Returns the image of self under a given permutation or rule. Remember, this is a passive transformation.

insert(index, *args)

Insert object before index.

property internal_masses_dict

property m2s

Masses squared of all particles in phase space.

make_analytical_d(indepVars=None, symbols=('a', 'b', 'c', 'd'))

momentum_conservation_check(silent=True)

Returns true if momentum is conserved.

property ms

Masses of all particles in phase space.

property multiplicity

onshell_relation_check(silent=True)

Returns true if all on-shell relations are satisfied.

phasespace_consistency_check(invariants=[], silent=True)

Runs momentum and onshell checks. Looks for outliers in phase space. Returns: mom_cons, on_shell, big_outliers, small_outliers.

randomise_all(real_momenta=False)

Randomises all particles. Breaks momentum conservation.

randomise_twistor()

save_phase_space_point(invariant='')

property spinors_are_in_field_extension

subs(myDict)

For all rank-1 spinor components, substitutes symbols with values from myDict.

property total_mom

Total momentum of the given phase space as a rank two spinor.

class lips.particles_compute.Particles_Compute

compute(original_temp_string)

Computes spinor strings.

Available variables: ⟨a|b⟩, [a|b], ⟨a|b+c|d], ⟨a|b+c|d+e|f], …, s_ijk, Δ_ijk, Ω_ijk, Π_ijk, tr5_ijkl

ee(i, j)

Contraction of two polarization tensors. Requires .helconf property to be set.

ep(i, j)

Contraction of polarization tensor with four momentum. Requires .helconf property to be set.

ldot(A, B)

Lorentz dot product: 2 trace(P^{α̇α}P̅̅_{αα̇}) = P_A^μ * η_μν * P_B^ν.

pe(i, j)

Contraction of four momentum with polarization tensor. Requires .helconf property to be set.

lips.particles_compute.as_scalar_if_scalar(func)

Turns numpy arrays with zero dimensions into ‘real’ scalars.

lips.particles_set

class lips.hardcoded_limits.particles_set.Particles_Set

lips.particles_set_pair

class lips.hardcoded_limits.particles_set_pair.Particles_SetPair

Module contents

Defines tools for phase space manipulations. Particles objects are base one lists of Particle objects.

Particles objects allow to:

1. Compute spinor strings, through .compute;

2. Construct single collinear limits, through .set;

3. Construct double collinear limits, through .set_pair.

oParticles = Particles(multiplicity)
oParticles.randomise_all()
oParticles.fix_mom_cons()
oParticles.compute(spinor_string)
oParticles.set(spinor_string, small_value)
oParticles.set_pair(spinor_string_1, small_value_1, spinor_string_2, small_value_2)