def evaluate_subtraction_current(
self, current,
higher_PS_point=None, lower_PS_point=None,
leg_numbers_map=None, reduced_process=None, hel_config=None,
Q=None, **opts ):
if higher_PS_point is None or lower_PS_point is None:
raise CurrentImplementationError(
self.name() + " needs the phase-space points before and after mapping." )
if leg_numbers_map is None:
raise CurrentImplementationError(
self.name() + " requires a leg numbers map, i.e. a momentum dictionary." )
if reduced_process is None:
raise CurrentImplementationError(
self.name() + " requires a reduced_process.")
if not hel_config is None:
raise CurrentImplementationError(
self.name() + " does not support helicity assignment." )
if Q is None:
raise CurrentImplementationError(
self.name() + " requires the total mapping momentum Q." )
# misc.sprint(self.__class__.__name__)
# misc.sprint(higher_PS_point)
# misc.sprint(lower_PS_point)
# Retrieve alpha_s and mu_r
model_param_dict = self.model.get('parameter_dict')
alpha_s = model_param_dict['aS']
mu_r = model_param_dict['MU_R']
# Include the counterterm only in a part of the phase space
children = self.get_sorted_children(current, self.model)
parent = leg_numbers_map.inv[frozenset(children)]
pC = sum(higher_PS_point[child] for child in children)
qC = lower_PS_point[parent]
if self.is_cut(Q=Q, pC=pC):
return utils.SubtractionCurrentResult.zero(
current=current, hel_config=hel_config)
# Evaluate collinear subtracted kernel
zs, kTs = self.variables(higher_PS_point, qC, children, Q=Q)
pr = higher_PS_point[children[0]]
ps = higher_PS_point[children[1]]
pi = higher_PS_point[children[2]]
sir = 2*pi.dot(pr)
sis = 2*pi.dot(ps)
srs = 2*pr.dot(ps)
evaluation = utils.SubtractionCurrentEvaluation.zero()
ker = 0
ker += 2*self.C123_kernel(zs[0], zs[1], zs[2], srs, sir, sis, sir+sis+srs)
ker -= 2*self.C123S12_kernel(zs[0], zs[1], zs[2], srs, sir, sis, sir+sis+srs)
ker -= self.C123C12_kernel(
higher_PS_point, lower_PS_point[parent], children, Q=Q, **opts)
ker += self.C123S12C12_kernel(
higher_PS_point, lower_PS_point[parent], children, Q=Q, **opts)
evaluation['values'][(0, 0)]['finite'] += 0.5*self.CF*self.TR*ker
# Find all colored leg numbers except for the parent in the reduced process
all_colored_parton_numbers = []
for leg in reduced_process.get('legs'):
if self.model.get_particle(leg.get('id')).get('color') == 1:
continue
all_colored_parton_numbers.append(leg.get('number'))
color_correlation_index = 1
# Now loop over the colored parton number pairs (parent, k)
# and add the corresponding contributions to this current
emitter = children[2]
for k in all_colored_parton_numbers:
spectator = k
if k == parent:
spectator = children[2]
evaluation['color_correlations'].append(((parent, k),))
weight = 0
if k != parent:
pk = higher_PS_point[k]
sik = 2*pi.dot(pk)
skr = 2*pk.dot(pr)
sks = 2*pk.dot(ps)
weight += self.S12_kernel(sir, sis, sik, skr, sks, srs)
weight -= 2*self.S12C12_kernel(
higher_PS_point, children, emitter, spectator, Q=Q, **opts)
evaluation['values'][(0, color_correlation_index)] = {'finite': weight}
color_correlation_index += 1
# Add the normalization factors
norm = (8. * math.pi * alpha_s) ** 2
norm *= self.factor(Q=Q, pC=pC, qC=qC)
for k in evaluation['values']:
evaluation['values'][k]['finite'] *= norm
# Construct and return result
result = utils.SubtractionCurrentResult()
result.add_result(
evaluation,
hel_config=hel_config,
squared_orders=tuple(sorted(current.get('squared_orders').items())))
return result
def evaluate_subtraction_current(self,
current,
higher_PS_point=None,
lower_PS_point=None,
leg_numbers_map=None,
reduced_process=None,
hel_config=None,
Q=None,
**opts):
"""Add the distributed partial fractioned soft eikonal approximation
to this hard collinear current
"""
if higher_PS_point is None or lower_PS_point is None:
raise CurrentImplementationError(
self.name() +
" needs the phase-space points before and after mapping.")
if leg_numbers_map is None:
raise CurrentImplementationError(
self.name() +
" requires a leg numbers map, i.e. a momentum dictionary.")
if reduced_process is None:
raise CurrentImplementationError(self.name() +
" requires a reduced_process.")
if not hel_config is None:
raise CurrentImplementationError(
self.name() + " does not support helicity assignment.")
if Q is None:
raise CurrentImplementationError(
self.name() + " requires the total mapping momentum Q.")
# Retrieve alpha_s and mu_r
model_param_dict = self.model.get('parameter_dict')
alpha_s = model_param_dict['aS']
mu_r = model_param_dict['MU_R']
# Include the counterterm only in a part of the phase space
children = self.get_sorted_children(current, self.model)
parent = leg_numbers_map.inv[frozenset(children)]
pC = higher_PS_point[children[0]]
pC -= sum(higher_PS_point[child] for child in children[1:])
if self.is_cut(Q=Q, pC=pC):
return utils.SubtractionCurrentResult.zero(current=current,
hel_config=hel_config)
# Evaluate collinear subtracted kernel
zs, kTs = self.variables(higher_PS_point,
lower_PS_point[parent],
children,
Q=Q)
evaluation = self.evaluate_kernel(zs, kTs, parent)
# Find all colored leg numbers except for the parent in the reduced process
all_colored_parton_numbers = []
for leg in reduced_process.get('legs'):
if self.model.get_particle(leg.get('id')).get('color') == 1:
continue
all_colored_parton_numbers.append(leg.get('number'))
color_correlation_index = 1
ps = higher_PS_point[children[1]]
pi = higher_PS_point[children[0]]
# pi = lower_PS_point[parent]
# Loop over the colored parton number pairs (parent, j)
# and add the corresponding contributions to this current
for j in all_colored_parton_numbers:
# Write the eikonal for that pair
# (positive here since the dipole end 'children[0]' is in the initial state)
if j == parent:
continue
pj = higher_PS_point[j]
# pj = sum(higher_PS_point[child] for child in leg_numbers_map[j])
# pj = lower_PS_point[j]
eik1 = mod_eikonal(pi, pj, ps)
evaluation['color_correlations'].append(((parent, j), ))
evaluation['values'][(0, color_correlation_index)] = {
'finite': eik1
}
color_correlation_index += 1
# Add the normalization factors
pC2 = pC.square()
norm = 8. * math.pi * alpha_s / pC2
norm *= self.factor(Q=Q, pC=pC)
for k in evaluation['values']:
evaluation['values'][k]['finite'] *= norm
# Construct and return result
result = utils.SubtractionCurrentResult()
result.add_result(evaluation,
hel_config=hel_config,
squared_orders=tuple(
sorted(current.get('squared_orders').items())))
return result