def evaluate_integrated_current(self,
current,
PS_point,
reduced_process=None,
leg_numbers_map=None,
hel_config=None,
compute_poles=False,
**opts):
""" Evaluates this current and return the corresponding instance of
SubtractionCurrentResult. See documentation of the mother function for more details."""
if not hel_config is None:
raise CurrentImplementationError(
"Subtraction current implementation " +
"%s does not support helicity assignment." %
self.__class__.__name__)
if leg_numbers_map is None:
raise CurrentImplementationError(
"Subtraction current implementation " +
"%s requires the leg_number_map." % self.__class__.__name__)
if reduced_process is None:
raise CurrentImplementationError(
"Subtraction current implementation " +
"%s requires a reduced_process." % self.__class__.__name__)
result = utils.SubtractionCurrentResult()
ss = current.get('singular_structure').substructures[0]
# 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']
# Retrieve kinematic variables from the specified PS point
soft_leg_number = ss.legs[0].n
# Use the momenta map, in case it has been remapped.
# Although for the soft current it's typically not the case
soft_leg_number = leg_numbers_map.inv[frozenset([
soft_leg_number,
])]
Q = sum([
PS_point[l.get('number')]
for l in reduced_process.get_initial_legs()
])
Q_square = Q.square()
# Now find all colored leg numbers 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'))
# Now instantiate what the result will be
evaluation = utils.SubtractionCurrentEvaluation({
'spin_correlations': [None],
'color_correlations': [],
'values': {}
})
logMuQ = math.log(mu_r**2 / Q_square)
prefactor = EpsilonExpansion({0: 1., 1: logMuQ, 2: 0.5 * logMuQ**2})
prefactor *= self.SEpsilon
# Now add the normalization factors
prefactor *= (alpha_s / (2. * math.pi))
prefactor.truncate(min_power=-2, max_power=2)
#Virtuality cut in the integration
y_0 = 0.5
color_correlation_index = 0
# Now loop over the colored parton number pairs (a,b)
# and add the corresponding contributions to this current
for i, a in enumerate(all_colored_parton_numbers):
# Use the symmetry of the color correlation and soft current (a,b) <-> (b,a)
for b in all_colored_parton_numbers[i + 1:]:
evaluation['color_correlations'].append(((a, b), ))
# We multiply by a factor 2. because we symmetrized the sum below
value = prefactor * 2.
pa = PS_point[a]
pb = PS_point[b]
Y = (pa.dot(pb) * Q_square) / (2. * Q.dot(pa) * Q.dot(pb))
finite_part = HE.SoftFF_Finite_Gabor_DIVJAC_NOD0(y_0, Y)
value *= EpsilonExpansion({
0: finite_part,
-1: math.log(Y),
-2: 0.
})
# Truncate expansion so as to keep only relevant terms
value.truncate(min_power=-2, max_power=0)
evaluation['values'][(
0,
color_correlation_index)] = value.to_human_readable_dict()
color_correlation_index += 1
result.add_result(evaluation,
hel_config=hel_config,
squared_orders=tuple(
sorted(current.get('squared_orders').items())))
return result
def evaluate_integrated_current(self,
current,
PS_point,
reduced_process=None,
leg_numbers_map=None,
hel_config=None,
compute_poles=False,
**opts):
""" Now evalaute the current and return the corresponding instance of
SubtractionCurrentResult. See documentation of the mother function for more details."""
if not hel_config is None:
raise CurrentImplementationError(
"Subtraction current implementation " +
"%s does not support helicity assignment." %
self.__class__.__name__)
if leg_numbers_map is None:
raise CurrentImplementationError(
"Subtraction current implementation " +
"%s requires the leg_number_map." % self.__class__.__name__)
if reduced_process is None:
raise CurrentImplementationError(
"Subtraction current implementation " +
"%s requires the reduced_process." % self.__class__.__name__)
result = utils.SubtractionCurrentResult()
ss = current.get('singular_structure').substructures[0]
# 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']
# Retrieve kinematic variables from the specified PS point
children_numbers = tuple(leg.n for leg in ss.legs)
parent_number = leg_numbers_map.inv[frozenset(children_numbers)]
p12 = PS_point[parent_number]
Q = sum([
PS_point[l.get('number')]
for l in reduced_process.get_initial_legs()
])
Q_square = Q.square()
y12 = 2. * Q.dot(p12) / Q_square
# Now instantiate what the result will be
evaluation = utils.SubtractionCurrentEvaluation({
'spin_correlations': [None],
'color_correlations': [None],
'values': {
(0, 0): {}
}
})
#Virtuality cut in the integration
alpha_0 = currents.SomogyiChoices.alpha_0
finite_part = HE.CggFF_Finite_Gabor_DIVJAC_NOD0(alpha_0, y12)
value = EpsilonExpansion({
0: finite_part,
-1: (11. / 3. - 4. * math.log(y12)),
-2: 2.
})
logMuQ = math.log(mu_r**2 / Q_square)
prefactor = EpsilonExpansion({0: 1., 1: logMuQ, 2: 0.5 * logMuQ**2})
prefactor *= self.SEpsilon
# Now add the normalization factors
value *= prefactor * (alpha_s / (2. * math.pi)) * self.CA
# Truncate expansion so as to keep only relevant terms
value.truncate(min_power=-2, max_power=0)
# Now register the value in the evaluation
evaluation['values'][(0, 0)] = value.to_human_readable_dict()
# And add it to the results
result.add_result(evaluation,
hel_config=hel_config,
squared_orders=tuple(
sorted(current.get('squared_orders').items())))
return result
