def test_f_product(self):
"""Test the fully contracted product of two f's"""
my_color_factor = color.ColorFactor([\
color.ColorString([color.f(1, 2, 3), color.f(1, 2, 3)])])
self.assertEqual(str(my_color_factor.full_simplify()),
'(-1 Nc^1 )+(1 Nc^3 )')
def test_T_f_product(self):
"""Test a non trivial T f f product"""
my_color_factor = color.ColorFactor([\
color.ColorString([color.T(-1000, 1, 2),
color.f(-1, -1000, 5),
color.f(-1, 4, 3)])])
self.assertEqual(str(my_color_factor.full_simplify()),
"(-1 T(5,4,3,1,2))+(1 T(5,3,4,1,2))+(1 T(4,3,5,1,2))+(-1 T(3,4,5,1,2))")
def test_three_f_chain(self):
"""Test a chain of three f's"""
my_color_factor = color.ColorFactor([\
color.ColorString([color.f(1, 2, -1),
color.f(-1, 3, -2),
color.f(-2, 4, 5)])])
self.assertEqual(str(my_color_factor.full_simplify()),
"(2 I Tr(1,2,3,4,5))+(-2 I Tr(1,2,4,5,3))+(-2 I Tr(1,2,3,5,4))" + \
"+(2 I Tr(1,2,5,4,3))+(-2 I Tr(1,3,4,5,2))+(2 I Tr(1,4,5,3,2))" + \
"+(2 I Tr(1,3,5,4,2))+(-2 I Tr(1,5,4,3,2))")
def test_gluons(self):
"""Test simplification of chains of f"""
my_col_fact = color.ColorFactor([color.ColorString([color.f(-3, 1, 2),
color.f(-1, 3, 4),
color.f(-1, 5, -3)
])])
self.assertEqual(str(my_col_fact.full_simplify()),
'(2 I Tr(1,2,3,4,5))+(-2 I Tr(1,2,5,3,4))+(-2 I Tr(1,2,4,3,5))+' + \
'(2 I Tr(1,2,5,4,3))+(-2 I Tr(1,3,4,5,2))+(2 I Tr(1,5,3,4,2))+' + \
'(2 I Tr(1,4,3,5,2))+(-2 I Tr(1,5,4,3,2))')
def test_f_d_product(self):
"""Test the fully contracted product of f and d"""
my_color_factor = color.ColorFactor([\
color.ColorString([color.f(1, 2, 3), color.d(1, 2, 3)])])
self.assertEqual(str(my_color_factor.full_simplify()), '')
def test_f_d_product(self):
"""Test the fully contracted product of f and d"""
my_color_factor = color.ColorFactor([\
color.ColorString([color.f(1, 2, 3), color.d(1, 2, 3)])])
self.assertEqual(str(my_color_factor.full_simplify()), '')
def test_colorize_uu_gg(self):
"""Test the colorize function for uu~ > gg"""
myleglist = base_objects.LegList()
myleglist.append(base_objects.Leg({'id': -2, 'state': False}))
myleglist.append(base_objects.Leg({'id': 2, 'state': False}))
myleglist.extend([base_objects.Leg({'id': 21, 'state': True})] * 2)
myprocess = base_objects.Process({
'legs': myleglist,
'model': self.mymodel
})
myamplitude = diagram_generation.Amplitude()
myamplitude.set('process', myprocess)
myamplitude.generate_diagrams()
my_col_basis = color_amp.ColorBasis()
# S channel
col_dict = my_col_basis.colorize(myamplitude['diagrams'][0],
self.mymodel)
goal_dict = {
(0, 0):
color.ColorString([color.T(-1000, 1, 2),
color.f(3, 4, -1000)])
}
self.assertEqual(col_dict, goal_dict)
# T channel
col_dict = my_col_basis.colorize(myamplitude['diagrams'][1],
self.mymodel)
goal_dict = {
(0, 0):
color.ColorString([color.T(3, 1, -1000),
color.T(4, -1000, 2)])
}
self.assertEqual(col_dict, goal_dict)
# U channel
col_dict = my_col_basis.colorize(myamplitude['diagrams'][2],
self.mymodel)
goal_dict = {
(0, 0):
color.ColorString([color.T(4, 1, -1000),
color.T(3, -1000, 2)])
}
self.assertEqual(col_dict, goal_dict)
def setUp(self):
"""Initialize the ColorString test"""
# Create a test color string
test_f = color.f(1, 2, 3)
test_d = color.d(4, 5, 6)
self.my_col_string = color.ColorString([test_f, test_d],
coeff=fractions.Fraction(2, 3),
Nc_power= -2,
is_imaginary=True)
def test_f_d_sum(self):
"""Test f and d sum with the right weights giving a Tr"""
col_str1 = color.ColorString([color.d(1, 2, 3)])
col_str1.coeff = fractions.Fraction(1, 4)
col_str2 = color.ColorString([color.f(1, 2, 3)])
col_str2.coeff = fractions.Fraction(1, 4)
col_str2.is_imaginary = True
my_color_factor = color.ColorFactor([col_str1, col_str2])
self.assertEqual(str(my_color_factor.full_simplify()), '(1 Tr(1,2,3))')
def test_f_d_sum(self):
"""Test f and d sum with the right weights giving a Tr"""
col_str1 = color.ColorString([color.d(1, 2, 3)])
col_str1.coeff = fractions.Fraction(1, 4)
col_str2 = color.ColorString([color.f(1, 2, 3)])
col_str2.coeff = fractions.Fraction(1, 4)
col_str2.is_imaginary = True
my_color_factor = color.ColorFactor([col_str1, col_str2])
self.assertEqual(str(my_color_factor.full_simplify()),
'(1 Tr(1,2,3))')
def test_colorize_uux_ggg(self):
"""Test the colorize function for uu~ > ggg"""
myleglist = base_objects.LegList()
myleglist.append(base_objects.Leg({'id':2,
'state':False}))
myleglist.append(base_objects.Leg({'id':-2,
'state':False}))
myleglist.extend([base_objects.Leg({'id':21,
'state':True})] * 3)
myprocess = base_objects.Process({'legs':myleglist,
'model':self.mymodel})
myamplitude = diagram_generation.Amplitude()
myamplitude.set('process', myprocess)
myamplitude.generate_diagrams()
my_col_basis = color_amp.ColorBasis()
# First diagram with two 3-gluon vertices
col_dict = my_col_basis.colorize(myamplitude['diagrams'][0],
self.mymodel)
goal_dict = {(0, 0, 0):color.ColorString([color.T(-1000, 2, 1),
color.f(-1001, 3, 4),
color.f(-1000, -1001, 5)])}
self.assertEqual(col_dict, goal_dict)
# Diagram with one 4-gluon vertex
col_dict = my_col_basis.colorize(myamplitude['diagrams'][3],
self.mymodel)
goal_dict = {(0, 0): color.ColorString([color.T(-1000,2,1),
color.f(-1001,3,5),
color.f(-1001,4,-1000)]),
(0, 1): color.ColorString([color.T(-1000,2,1),
color.f(-1002,3,-1000),
color.f(-1002,4,5)]),
(0, 2): color.ColorString([color.T(-1000,2,1),
color.f(-1003,3,4),
color.f(-1003,5,-1000)])}
self.assertEqual(col_dict, goal_dict)
def test_colorize_uu_gg(self):
"""Test the colorize function for uu~ > gg"""
myleglist = base_objects.LegList()
myleglist.append(base_objects.Leg({'id':-2,
'state':False}))
myleglist.append(base_objects.Leg({'id':2,
'state':False}))
myleglist.extend([base_objects.Leg({'id':21,
'state':True})] * 2)
myprocess = base_objects.Process({'legs':myleglist,
'model':self.mymodel})
myamplitude = diagram_generation.Amplitude()
myamplitude.set('process', myprocess)
myamplitude.generate_diagrams()
my_col_basis = color_amp.ColorBasis()
# S channel
col_dict = my_col_basis.colorize(myamplitude['diagrams'][0],
self.mymodel)
goal_dict = {(0, 0):color.ColorString([color.T(-1000, 1, 2),
color.f(3, 4, -1000)])}
self.assertEqual(col_dict, goal_dict)
# T channel
col_dict = my_col_basis.colorize(myamplitude['diagrams'][1],
self.mymodel)
goal_dict = {(0, 0):color.ColorString([color.T(3, 1, -1000),
color.T(4, -1000, 2)])}
self.assertEqual(col_dict, goal_dict)
# U channel
col_dict = my_col_basis.colorize(myamplitude['diagrams'][2],
self.mymodel)
goal_dict = {(0, 0):color.ColorString([color.T(4, 1, -1000),
color.T(3,-1000, 2)])}
self.assertEqual(col_dict, goal_dict)
def test_f_object(self):
"""Test the f color object"""
# T should have exactly 3 indices!
self.assertRaises(AssertionError, color.f, 1, 2, 3, 4)
# Simplify should always return the same ColorFactor
my_f = color.f(1, 2, 3)
col_str1 = color.ColorString([color.Tr(1, 2, 3)])
col_str2 = color.ColorString([color.Tr(3, 2, 1)])
col_str1.coeff = fractions.Fraction(-2, 1)
col_str2.coeff = fractions.Fraction(2, 1)
col_str1.is_imaginary = True
col_str2.is_imaginary = True
self.assertEqual(my_f.simplify(),
color.ColorFactor([col_str1, col_str2]))
def test_f_object(self):
"""Test the f color object"""
# T should have exactly 3 indices!
self.assertRaises(AssertionError,
color.f,
1, 2, 3, 4)
# Simplify should always return the same ColorFactor
my_f = color.f(1, 2, 3)
col_str1 = color.ColorString([color.Tr(1, 2, 3)])
col_str2 = color.ColorString([color.Tr(3, 2, 1)])
col_str1.coeff = fractions.Fraction(-2, 1)
col_str2.coeff = fractions.Fraction(2, 1)
col_str1.is_imaginary = True
col_str2.is_imaginary = True
self.assertEqual(my_f.simplify(),
color.ColorFactor([col_str1, col_str2]))
def read_interactions_v4(fsock, ref_part_list):
"""Read a list of interactions from stream fsock, using the old v4 format.
Requires a ParticleList object as an input to recognize particle names."""
logger.info('load interactions')
myinterlist = InteractionList()
if not isinstance(ref_part_list, ParticleList):
raise ValueError, \
"Object %s is not a valid ParticleList" % repr(ref_part_list)
for line in fsock:
myinter = Interaction()
line = line.split("#", 2)[0] # remove any comment
line = line.strip() # makes the string clean
if line != "": # skip blank
values = line.split()
part_list = ParticleList()
try:
for str_name in values:
curr_part = ref_part_list.get_copy(str_name.lower())
if isinstance(curr_part, Particle):
# Look at the total number of strings, stop if
# anyway not enough, required if a variable name
# corresponds to a particle! (eg G)
if len(values) >= 2 * len(part_list) + 1:
part_list.append(curr_part)
else:
break
# also stops if string does not correspond to
# a particle name
else:
break
if len(part_list) < 3:
raise Interaction.PhysicsObjectError, \
"Vertex with less than 3 known particles found."
# Flip part/antipart of first part for FFV, FFS, FFT vertices
# according to v4 convention
spin_array = [part['spin'] for part in part_list]
if spin_array[:2] == [2, 2] and \
not part_list[0].get('self_antipart'):
part_list[0]['is_part'] = not part_list[0]['is_part']
myinter.set('particles', part_list)
# Give color structure
# Order particles according to color
# Don't consider singlets
color_parts = sorted(enumerate(part_list), lambda p1, p2:\
p1[1].get_color() - p2[1].get_color())
color_ind = [(i, part.get_color()) for i, part in \
color_parts if part.get_color() !=1]
colors = [c for i, c in color_ind]
ind = [i for i, c in color_ind]
# Set color empty by default
myinter.set('color', [])
if not colors:
# All color singlets - set empty
pass
elif colors == [-3, 3]:
# triplet-triplet-singlet coupling
myinter.set('color', [color.ColorString(\
[color.T(ind[1], ind[0])])])
elif colors == [8, 8]:
# octet-octet-singlet coupling
my_cs = color.ColorString(\
[color.Tr(ind[0], ind[1])])
my_cs.coeff = fractions.Fraction(2)
myinter.set('color', [my_cs])
elif colors == [-3, 3, 8]:
# triplet-triplet-octet coupling
myinter.set('color', [color.ColorString(\
[color.T(ind[2], ind[1], ind[0])])])
elif colors == [8, 8, 8]:
# Triple glue coupling
my_color_string = color.ColorString(\
[color.f(ind[0], ind[1], ind[2])])
my_color_string.is_imaginary = True
myinter.set('color', [my_color_string])
elif colors == [-3, 3, 8, 8]:
my_cs1 = color.ColorString(\
[color.T(ind[2], ind[3], ind[1], ind[0])])
my_cs2 = color.ColorString(\
[color.T(ind[3], ind[2], ind[1], ind[0])])
myinter.set('color', [my_cs1, my_cs2])
elif colors == [8, 8, 8, 8]:
# 4-glue coupling
cs1 = color.ColorString(
[color.f(0, 1, -1),
color.f(2, 3, -1)])
#cs1.coeff = fractions.Fraction(-1)
cs2 = color.ColorString(
[color.f(2, 0, -1),
color.f(1, 3, -1)])
#cs2.coeff = fractions.Fraction(-1)
cs3 = color.ColorString(
[color.f(1, 2, -1),
color.f(0, 3, -1)])
#cs3.coeff = fractions.Fraction(-1)
myinter.set('color', [cs1, cs2, cs3])
# The following line are expected to be correct but not physical validations
# have been performed. So we keep it commented for the moment.
# elif colors == [3, 3, 3]:
# my_color_string = color.ColorString(\
# [color.Epsilon(ind[0], ind[1], ind[2])])
# myinter.set('color', [my_color_string])
# elif colors == [-3, -3, -3]:
# my_color_string = color.ColorString(\
# [color.EpsilonBar(ind[0], ind[1], ind[2])])
# myinter.set('color', [my_color_string])
else:
logger.warning(\
"Color combination %s not yet implemented." % \
repr(colors))
# Set the Lorentz structure. Default for 3-particle
# vertices is empty string, for 4-particle pair of
# empty strings
myinter.set('lorentz', [''])
pdg_codes = sorted([part.get_pdg_code() for part in part_list])
# WWWW and WWVV
if pdg_codes == [-24, -24, 24, 24]:
myinter.set('lorentz', ['WWWW'])
elif spin_array == [3, 3, 3, 3] and \
24 in pdg_codes and - 24 in pdg_codes:
myinter.set('lorentz', ['WWVV'])
# gggg
if pdg_codes == [21, 21, 21, 21]:
myinter.set('lorentz', ['gggg1', 'gggg2', 'gggg3'])
# go-go-g
# Using the special fvigox routine provides the minus
# sign necessary for octet Majorana-vector interactions
if spin_array == [2, 2, 3] and colors == [8, 8, 8] and \
part_list[0].get('self_antipart') and \
part_list[1].get('self_antipart'):
myinter.set('lorentz', ['go'])
# If extra flag, add this to Lorentz
if len(values) > 3 * len(part_list) - 4:
myinter.get('lorentz')[0] = \
myinter.get('lorentz')[0]\
+ values[3 * len(part_list) - 4].upper()
# Use the other strings to fill variable names and tags
# Couplings: special treatment for 4-vertices, where MG4 used
# two couplings, while MG5 only uses one (with the exception
# of the 4g vertex, which needs special treatment)
# DUM0 and DUM1 are used as placeholders by FR, corresponds to 1
if len(part_list) == 3 or \
values[len(part_list) + 1] in ['DUM', 'DUM0', 'DUM1']:
# We can just use the first coupling, since the second
# is a dummy
myinter.set('couplings', {(0, 0): values[len(part_list)]})
if myinter.get('lorentz')[0] == 'WWWWN':
# Should only use one Helas amplitude for electroweak
# 4-vector vertices with FR. I choose W3W3NX.
myinter.set('lorentz', ['WWVVN'])
elif values[len(part_list)] in ['DUM', 'DUM0', 'DUM1']:
# We can just use the second coupling, since the first
# is a dummy
myinter.set('couplings',
{(0, 0): values[len(part_list) + 1]})
elif pdg_codes == [21, 21, 21, 21]:
# gggg
myinter.set(
'couplings', {
(0, 0): values[len(part_list)],
(1, 1): values[len(part_list)],
(2, 2): values[len(part_list)]
})
elif myinter.get('lorentz')[0] == 'WWWW':
# Need special treatment of v4 SM WWWW couplings since
# MG5 can only have one coupling per Lorentz structure
myinter.set('couplings', {(0, 0):\
'sqrt(' +
values[len(part_list)] + \
'**2+' + \
values[len(part_list) + 1] + \
'**2)'})
else: #if myinter.get('lorentz')[0] == 'WWVV':
# Need special treatment of v4 SM WWVV couplings since
# MG5 can only have one coupling per Lorentz structure
myinter.set('couplings', {(0, 0):values[len(part_list)] + \
'*' + \
values[len(part_list) + 1]})
#raise Interaction.PhysicsObjectError, \
# "Only FR-style 4-vertices implemented."
# SPECIAL TREATMENT OF COLOR
# g g sq sq (two different color structures, same Lorentz)
if spin_array == [3, 3, 1, 1] and colors == [-3, 3, 8, 8]:
myinter.set(
'couplings', {
(0, 0): values[len(part_list)],
(1, 0): values[len(part_list)]
})
# Coupling orders - needs to be fixed
order_list = values[2 * len(part_list) - 2: \
3 * len(part_list) - 4]
def count_duplicates_in_list(dupedlist):
"""return a dictionary with key the element of dupeList and
with value the number of times that they are in this list"""
unique_set = set(item for item in dupedlist)
ret_dict = {}
for item in unique_set:
ret_dict[item] = dupedlist.count(item)
return ret_dict
myinter.set('orders', count_duplicates_in_list(order_list))
myinter.set('id', len(myinterlist) + 1)
myinterlist.append(myinter)
except Interaction.PhysicsObjectError, why:
logger.error("Interaction ignored: %s" % why)
def read_interactions_v4(fsock, ref_part_list):
"""Read a list of interactions from stream fsock, using the old v4 format.
Requires a ParticleList object as an input to recognize particle names."""
logger.info('load interactions')
myinterlist = InteractionList()
if not isinstance(ref_part_list, ParticleList):
raise ValueError, \
"Object %s is not a valid ParticleList" % repr(ref_part_list)
for line in fsock:
myinter = Interaction()
line = line.split("#", 2)[0] # remove any comment
line = line.strip() # makes the string clean
if line != "": # skip blank
values = line.split()
part_list = ParticleList()
try:
for str_name in values:
curr_part = ref_part_list.get_copy(str_name.lower())
if isinstance(curr_part, Particle):
# Look at the total number of strings, stop if
# anyway not enough, required if a variable name
# corresponds to a particle! (eg G)
if len(values) >= 2 * len(part_list) + 1:
part_list.append(curr_part)
else: break
# also stops if string does not correspond to
# a particle name
else: break
if len(part_list) < 3:
raise Interaction.PhysicsObjectError, \
"Vertex with less than 3 known particles found."
# Flip part/antipart of first part for FFV, FFS, FFT vertices
# according to v4 convention
spin_array = [part['spin'] for part in part_list]
if spin_array[:2] == [2, 2] and \
not part_list[0].get('self_antipart'):
part_list[0]['is_part'] = not part_list[0]['is_part']
myinter.set('particles', part_list)
# Give color structure
# Order particles according to color
# Don't consider singlets
color_parts = sorted(enumerate(part_list), lambda p1, p2:\
p1[1].get_color() - p2[1].get_color())
color_ind = [(i, part.get_color()) for i, part in \
color_parts if part.get_color() !=1]
colors = [c for i,c in color_ind]
ind = [i for i,c in color_ind]
# Set color empty by default
myinter.set('color', [])
if not colors:
# All color singlets - set empty
pass
elif colors == [-3, 3]:
# triplet-triplet-singlet coupling
myinter.set('color', [color.ColorString(\
[color.T(ind[1], ind[0])])])
elif colors == [8, 8]:
# octet-octet-singlet coupling
my_cs = color.ColorString(\
[color.Tr(ind[0], ind[1])])
my_cs.coeff = fractions.Fraction(2)
myinter.set('color', [my_cs])
elif colors == [-3, 3, 8]:
# triplet-triplet-octet coupling
myinter.set('color', [color.ColorString(\
[color.T(ind[2], ind[1], ind[0])])])
elif colors == [8, 8, 8]:
# Triple glue coupling
my_color_string = color.ColorString(\
[color.f(ind[0], ind[1], ind[2])])
my_color_string.is_imaginary = True
myinter.set('color', [my_color_string])
elif colors == [-3, 3, 8, 8]:
my_cs1 = color.ColorString(\
[color.T(ind[2], ind[3], ind[1], ind[0])])
my_cs2 = color.ColorString(\
[color.T(ind[3], ind[2], ind[1], ind[0])])
myinter.set('color', [my_cs1, my_cs2])
elif colors == [8, 8, 8, 8]:
# 4-glue coupling
cs1 = color.ColorString([color.f(0, 1, -1),
color.f(2, 3, -1)])
#cs1.coeff = fractions.Fraction(-1)
cs2 = color.ColorString([color.f(2, 0, -1),
color.f(1, 3, -1)])
#cs2.coeff = fractions.Fraction(-1)
cs3 = color.ColorString([color.f(1, 2, -1),
color.f(0, 3, -1)])
#cs3.coeff = fractions.Fraction(-1)
myinter.set('color', [cs1, cs2, cs3])
# The following line are expected to be correct but not physical validations
# have been performed. So we keep it commented for the moment.
# elif colors == [3, 3, 3]:
# my_color_string = color.ColorString(\
# [color.Epsilon(ind[0], ind[1], ind[2])])
# myinter.set('color', [my_color_string])
# elif colors == [-3, -3, -3]:
# my_color_string = color.ColorString(\
# [color.EpsilonBar(ind[0], ind[1], ind[2])])
# myinter.set('color', [my_color_string])
else:
logger.warning(\
"Color combination %s not yet implemented." % \
repr(colors))
# Set the Lorentz structure. Default for 3-particle
# vertices is empty string, for 4-particle pair of
# empty strings
myinter.set('lorentz', [''])
pdg_codes = sorted([part.get_pdg_code() for part in part_list])
# WWWW and WWVV
if pdg_codes == [-24, -24, 24, 24]:
myinter.set('lorentz', ['WWWW'])
elif spin_array == [3, 3, 3, 3] and \
24 in pdg_codes and - 24 in pdg_codes:
myinter.set('lorentz', ['WWVV'])
# gggg
if pdg_codes == [21, 21, 21, 21]:
myinter.set('lorentz', ['gggg1', 'gggg2', 'gggg3'])
# go-go-g
# Using the special fvigox routine provides the minus
# sign necessary for octet Majorana-vector interactions
if spin_array == [2, 2, 3] and colors == [8, 8, 8] and \
part_list[0].get('self_antipart') and \
part_list[1].get('self_antipart'):
myinter.set('lorentz', ['go'])
# If extra flag, add this to Lorentz
if len(values) > 3 * len(part_list) - 4:
myinter.get('lorentz')[0] = \
myinter.get('lorentz')[0]\
+ values[3 * len(part_list) - 4].upper()
# Use the other strings to fill variable names and tags
# Couplings: special treatment for 4-vertices, where MG4 used
# two couplings, while MG5 only uses one (with the exception
# of the 4g vertex, which needs special treatment)
# DUM0 and DUM1 are used as placeholders by FR, corresponds to 1
if len(part_list) == 3 or \
values[len(part_list) + 1] in ['DUM', 'DUM0', 'DUM1']:
# We can just use the first coupling, since the second
# is a dummy
myinter.set('couplings', {(0, 0):values[len(part_list)]})
if myinter.get('lorentz')[0] == 'WWWWN':
# Should only use one Helas amplitude for electroweak
# 4-vector vertices with FR. I choose W3W3NX.
myinter.set('lorentz', ['WWVVN'])
elif values[len(part_list)] in ['DUM', 'DUM0', 'DUM1']:
# We can just use the second coupling, since the first
# is a dummy
myinter.set('couplings', {(0, 0):values[len(part_list)+1]})
elif pdg_codes == [21, 21, 21, 21]:
# gggg
myinter.set('couplings', {(0, 0):values[len(part_list)],
(1, 1):values[len(part_list)],
(2, 2):values[len(part_list)]})
elif myinter.get('lorentz')[0] == 'WWWW':
# Need special treatment of v4 SM WWWW couplings since
# MG5 can only have one coupling per Lorentz structure
myinter.set('couplings', {(0, 0):\
'sqrt(' +
values[len(part_list)] + \
'**2+' + \
values[len(part_list) + 1] + \
'**2)'})
else: #if myinter.get('lorentz')[0] == 'WWVV':
# Need special treatment of v4 SM WWVV couplings since
# MG5 can only have one coupling per Lorentz structure
myinter.set('couplings', {(0, 0):values[len(part_list)] + \
'*' + \
values[len(part_list) + 1]})
#raise Interaction.PhysicsObjectError, \
# "Only FR-style 4-vertices implemented."
# SPECIAL TREATMENT OF COLOR
# g g sq sq (two different color structures, same Lorentz)
if spin_array == [3, 3, 1, 1] and colors == [-3, 3, 8, 8]:
myinter.set('couplings', {(0, 0):values[len(part_list)],
(1, 0):values[len(part_list)]})
# Coupling orders - needs to be fixed
order_list = values[2 * len(part_list) - 2: \
3 * len(part_list) - 4]
def count_duplicates_in_list(dupedlist):
"""return a dictionary with key the element of dupeList and
with value the number of times that they are in this list"""
unique_set = set(item for item in dupedlist)
ret_dict = {}
for item in unique_set:
ret_dict[item] = dupedlist.count(item)
return ret_dict
myinter.set('orders', count_duplicates_in_list(order_list))
myinter.set('id', len(myinterlist) + 1)
myinterlist.append(myinter)
except Interaction.PhysicsObjectError, why:
logger.error("Interaction ignored: %s" % why)
def legs_to_color_link_string(leg1, leg2): #test written, all cases
"""given two FKSlegs, returns a dictionary containing:
--string: the color link between the two particles, to be appended to
the old color string
extra minus or 1/2 factor are included as it was done in MadDipole
--replacements: a pair of lists containing the replacements of the color
indices in the old string to match the link
"""
#the second-to-last index of the t is the triplet,
# the last is the anti-triplet
legs = FKSLegList([leg1, leg2])
dict = {}
min_index = -3000
iglu = min_index * 2
string = color_algebra.ColorString()
replacements = []
if leg1 != leg2:
for leg in legs:
min_index -= 1
num = leg.get('number')
replacements.append([num, min_index])
icol = 1
if not leg.get('state'):
icol = -1
if leg.get('color') * icol == 3:
string.product(
color_algebra.ColorString(
[color_algebra.T(iglu, num, min_index)]))
string.coeff = string.coeff * (-1)
elif leg.get('color') * icol == -3:
string.product(
color_algebra.ColorString(
[color_algebra.T(iglu, min_index, num)]))
elif leg.get('color') == 8:
string.product(
color_algebra.ColorString(
init_list=[color_algebra.f(min_index, iglu, num)],
is_imaginary=True))
else:
icol = 1
if not leg1.get('state'):
icol = -1
num = leg1.get('number')
replacements.append([num, min_index - 1])
if leg1.get('color') * icol == 3:
string = color_algebra.ColorString(
[color_algebra.T(iglu, iglu, num, min_index - 1)])
elif leg1.get('color') * icol == -3:
string = color_algebra.ColorString(
[color_algebra.T(iglu, iglu, min_index - 1, num)])
elif leg1.get('color') == 8:
string = color_algebra.ColorString(
init_list=[color_algebra.f(min_index - 1, iglu, min_index)],
is_imaginary=True)
string.product(
color_algebra.ColorString(
init_list=[color_algebra.f(min_index, iglu, num)],
is_imaginary=True))
string.coeff = string.coeff * fractions.Fraction(1, 2)
dict['replacements'] = replacements
dict['string'] = string
return dict
def setUp(self):
# A gluon
self.mypartlist.append(base_objects.Particle({'name':'g',
'antiname':'g',
'spin':3,
'color':8,
'mass':'zero',
'width':'zero',
'texname':'g',
'antitexname':'g',
'line':'curly',
'charge':0.,
'pdg_code':21,
'propagating':True,
'is_part':True,
'self_antipart':True}))
# A quark U and its antiparticle
self.mypartlist.append(base_objects.Particle({'name':'u',
'antiname':'u~',
'spin':2,
'color':3,
'mass':'zero',
'width':'zero',
'texname':'u',
'antitexname':'\bar u',
'line':'straight',
'charge':2. / 3.,
'pdg_code':2,
'propagating':True,
'is_part':True,
'self_antipart':False}))
antiu = copy.copy(self.mypartlist[1])
antiu.set('is_part', False)
# A quark D and its antiparticle
self.mypartlist.append(base_objects.Particle({'name':'d',
'antiname':'d~',
'spin':2,
'color':3,
'mass':'zero',
'width':'zero',
'texname':'u',
'antitexname':'\bar u',
'line':'straight',
'charge':-1. / 3.,
'pdg_code':1,
'propagating':True,
'is_part':True,
'self_antipart':False}))
antid = copy.copy(self.mypartlist[2])
antid.set('is_part', False)
# 3 gluon vertiex
self.myinterlist.append(base_objects.Interaction({
'id': 1,
'particles': base_objects.ParticleList(\
[self.mypartlist[0]] * 3),
'color': [color.ColorString([color.f(0, 1, 2)])],
'lorentz':['L1'],
'couplings':{(0, 0):'G'},
'orders':{'QCD':1}}))
# 4 gluon vertex
self.myinterlist.append(base_objects.Interaction({
'id': 2,
'particles': base_objects.ParticleList(\
[self.mypartlist[0]] * 4),
'color': [color.ColorString([color.f(-1, 0, 2),
color.f(-1, 1, 3)]),
color.ColorString([color.f(-1, 0, 3),
color.f(-1, 1, 2)]),
color.ColorString([color.f(-1, 0, 1),
color.f(-1, 2, 3)])],
'lorentz':['L(p1,p2,p3)', 'L(p2,p3,p1)', 'L3'],
'couplings':{(0, 0):'G^2',
(1, 1):'G^2',
(2, 2):'G^2'},
'orders':{'QCD':2}}))
# Gluon couplings to up and down quarks
self.myinterlist.append(base_objects.Interaction({
'id': 3,
'particles': base_objects.ParticleList(\
[self.mypartlist[1], \
antiu, \
self.mypartlist[0]]),
'color': [color.ColorString([color.T(2, 0, 1)])],
'lorentz':['L1'],
'couplings':{(0, 0):'GQQ'},
'orders':{'QCD':1}}))
self.myinterlist.append(base_objects.Interaction({
'id': 4,
'particles': base_objects.ParticleList(\
[self.mypartlist[2], \
antid, \
self.mypartlist[0]]),
'color': [color.ColorString([color.T(2, 0, 1)])],
'lorentz':['L1'],
'couplings':{(0, 0):'GQQ'},
'orders':{'QCD':1}}))
self.mymodel.set('particles', self.mypartlist)
self.mymodel.set('interactions', self.myinterlist)
def test_colorize_funny_model(self):
"""Test the colorize function for uu~ > ggg"""
mypartlist = base_objects.ParticleList()
myinterlist = base_objects.InteractionList()
mymodel = base_objects.Model()
# A gluon
mypartlist.append(base_objects.Particle({'name':'g',
'antiname':'g',
'spin':3,
'color':8,
'mass':'zero',
'width':'zero',
'texname':'g',
'antitexname':'g',
'line':'curly',
'charge':0.,
'pdg_code':21,
'propagating':True,
'is_part':True,
'self_antipart':True}))
# 3 gluon vertiex
myinterlist.append(base_objects.Interaction({
'id': 1,
'particles': base_objects.ParticleList(\
[mypartlist[0]] * 3),
'color': [color.ColorString([color.f(0, 1, 2)]),
color.ColorString([color.f(0, 2, 1)]),
color.ColorString([color.f(1, 2, 0)])],
'lorentz':['L1'],
'couplings':{(0, 0):'G', (2,0):'G'},
'orders':{'QCD':1}}))
mymodel.set('particles', mypartlist)
mymodel.set('interactions', myinterlist)
myleglist = base_objects.LegList()
myleglist.append(base_objects.Leg({'id':21,
'state':False}))
myleglist.append(base_objects.Leg({'id':21,
'state':False}))
myleglist.extend([base_objects.Leg({'id':21,
'state':True})] * 2)
myprocess = base_objects.Process({'legs':myleglist,
'model':mymodel})
myamplitude = diagram_generation.Amplitude()
myamplitude.set('process', myprocess)
myamplitude.generate_diagrams()
my_col_basis = color_amp.ColorBasis()
# Check that only the color structures that are actually used are included
col_dict = my_col_basis.colorize(myamplitude['diagrams'][0],
mymodel)
goal_dict = {(2, 0): color.ColorString([color.f(1,2,-1000),
color.f(3,4,-1000)]),
(0, 0): color.ColorString([color.f(-1000,1,2),
color.f(3,4,-1000)]),
(0, 2): color.ColorString([color.f(-1000,1,2),
color.f(4,-1000,3)]),
(2, 2): color.ColorString([color.f(1,2,-1000),
color.f(4,-1000,3)])}
self.assertEqual(col_dict, goal_dict)
def test_read_interactions(self):
"""Test the output of import interactions.dat file"""
particles_dat_str = """ve ve~ F S ZERO ZERO S ve 12
vm vm~ F S ZERO ZERO S vm 14
vt vt~ F S ZERO ZERO S vt 16
e- e+ F S ZERO ZERO S e 11
m- m+ F S ZERO ZERO S m 13
tt- tt+ F S MTA ZERO S tt 15
u u~ F S ZERO ZERO T u 2
c c~ F S MC ZERO T c 4
t t~ F S MT WT T t 6
d d~ F S ZERO ZERO T d 1
s s~ F S ZERO ZERO T s 3
b b~ F S MB ZERO T b 5
a a V W ZERO ZERO S a 22
z z V W MZ WZ S Z 23
w+ w- V W MW WW S W 24
g g V C ZERO ZERO O G 21
h h S D MH WH S H 25
T1 T1 T D ZERO ZERO O T1 8000002"""
interactions_dat_str = """# Interactions associated with Standard_Model
w+ w- a MGVX3 QED
g g T1 MGVX2 QCD a
w+ w- w+ w- MGVX6 DUM0 QED QED n
e- ve w- MGVX24 QED
e+ ve~ w+ MGVX25 QED
u u g MGVX1 QCD
u u a MGVX4 QED
# And now some bad format entries
# which should be ignored with a warning
k+ k- a test QED
g g test QCD"""
fsock_part = StringIO.StringIO(particles_dat_str)
fsock_inter = StringIO.StringIO(interactions_dat_str)
myparts = import_v4.read_particles_v4(fsock_part)
wplus = copy.copy(myparts[14])
wmin = copy.copy(myparts[14])
wmin.set('is_part', False)
eminus = copy.copy(myparts[3])
eplus = copy.copy(myparts[3])
eplus.set('is_part', False)
enu = copy.copy(myparts[0])
enubar = copy.copy(myparts[0])
enubar.set('is_part', False)
photon = copy.copy(myparts[12])
gluon = copy.copy(myparts[15])
t1 = copy.copy(myparts[17])
u = myparts[6]
ubar = copy.copy(myparts[6])
ubar.set('is_part', False)
my_i_f = color.ColorString([color.f(0, 1, 2)])
my_i_f.is_imaginary = True
goal_inter_list = base_objects.InteractionList([ \
base_objects.Interaction(
{'id':1,
'particles':base_objects.ParticleList([
wplus,
wmin,
photon]),
'color':[],
'lorentz':[''],
'couplings':{(0, 0):'MGVX3'},
'orders':{'QED':1}}),
base_objects.Interaction(
{'id':2,
'particles':base_objects.ParticleList([
gluon,
gluon,
t1]),
'color':[my_i_f],
'lorentz':['A'],
'couplings':{(0, 0):'MGVX2'},
'orders':{'QCD':1}}),
base_objects.Interaction(
{'id':3,
'particles':base_objects.ParticleList([
wplus,
wmin,
wplus,
wmin]),
'color':[],
'lorentz':['WWVVN'],
'couplings':{(0, 0):'MGVX6'},
'orders':{'QED':2}}),
base_objects.Interaction(
{'id':4,
'particles':base_objects.ParticleList([
eplus,
enu,
wmin]),
'color':[],
'lorentz':[''],
'couplings':{(0, 0):'MGVX24'},
'orders':{'QED':1}}),
base_objects.Interaction(
{'id':5,
'particles':base_objects.ParticleList([
eminus,
enubar,
wplus]),
'color':[],
'lorentz':[''],
'couplings':{(0, 0):'MGVX25'},
'orders':{'QED':1}}),
base_objects.Interaction(
{'id':6,
'particles':base_objects.ParticleList([
ubar,
u,
gluon]),
'color':[color.ColorString(\
[color.T(2, 1, 0)])],
'lorentz':[''],
'couplings':{(0, 0):'MGVX1'},
'orders':{'QCD':1}}),
base_objects.Interaction(
{'id':7,
'particles':base_objects.ParticleList([
ubar,
u,
photon]),
'color':[color.ColorString(\
[color.T(1, 0)])],
'lorentz':[''],
'couplings':{(0, 0):'MGVX4'},
'orders':{'QED':1}})])
result = import_v4.read_interactions_v4(fsock_inter, myparts)
self.assertEqual(len(result), len(goal_inter_list))
for i in range(len(result)):
self.assertEqual(result[i], goal_inter_list[i])
'is_part': True,
'self_antipart': True
})
particles = base_objects.ParticleList([gluon, up, down, photon, higgs])
# Interactions
#=========================================================================================
interactions = base_objects.InteractionList()
# g g g
interactions.append(base_objects.Interaction({
'id': 1,
'particles': base_objects.ParticleList([gluon, ] * 3),
'color': [color.ColorString([color.f(0, 1, 2)])],
'lorentz': ['L1'],
'couplings': {(0, 0): 'G'},
'orders': {'QCD': 1}
}))
# g g g g
interactions.append(base_objects.Interaction({
'id': 2,
'particles': base_objects.ParticleList([gluon, ] * 4),
'color': [
color.ColorString([color.f(-1, 0, 2), color.f(-1, 1, 3)]),
color.ColorString([color.f(-1, 0, 3), color.f(-1, 1, 2)]),
color.ColorString([color.f(-1, 0, 1), color.f(-1, 2, 3)])
],
'lorentz': ['L(p1,p2,p3)', 'L(p2,p3,p1)', 'L3'],
def legs_to_color_link_string(leg1, leg2, pert = 'QCD'): #test written, all cases
"""given two FKSlegs, returns a dictionary containing:
--string: the color link between the two particles, to be appended to
the old color string
extra minus or 1/2 factor are included as it was done in MadDipole
--replacements: a pair of lists containing the replacements of the color
indices in the old string to match the link
"""
#the second-to-last index of the t is the triplet,
# the last is the anti-triplet
legs = FKSLegList([leg1, leg2])
dict = {}
min_index = -3000
iglu = min_index*2
string = color_algebra.ColorString()
replacements = []
if pert == 'QCD':
if leg1 != leg2:
for leg in legs:
min_index -= 1
num = leg.get('number')
replacements.append([num, min_index])
icol = 1
if not leg.get('state'):
icol = - 1
if leg.get('color') * icol == 3:
string.product(color_algebra.ColorString([
color_algebra.T(iglu, num, min_index)]))
string.coeff = string.coeff * (-1)
elif leg.get('color') * icol == - 3:
string.product(color_algebra.ColorString([
color_algebra.T(iglu, min_index, num)]))
elif leg.get('color') == 8:
string.product(color_algebra.ColorString(init_list = [
color_algebra.f(min_index,iglu,num)],
is_imaginary =True))
else:
icol = 1
if not leg1.get('state'):
icol = - 1
num = leg1.get('number')
replacements.append([num, min_index -1])
if leg1.get('color') * icol == 3:
string = color_algebra.ColorString(
[color_algebra.T(iglu, iglu, num, min_index -1)])
elif leg1.get('color') * icol == - 3:
string = color_algebra.ColorString(
[color_algebra.T(iglu, iglu, min_index-1, num)])
elif leg1.get('color') == 8:
string = color_algebra.ColorString(init_list = [
color_algebra.f(min_index-1,iglu,min_index)],
is_imaginary =True)
string.product(color_algebra.ColorString(init_list = [
color_algebra.f(min_index,iglu,num)],
is_imaginary =True))
string.coeff = string.coeff * fractions.Fraction(1, 2)
elif pert == 'QED':
for leg in legs:
# make it a fraction
string.coeff = string.coeff * fractions.Fraction(leg['charge']*3.)*\
fractions.Fraction(1,3)
else:
raise FKSProcessError,"Only QCD or QED is allowed not %s"% pert
dict['replacements'] = replacements
dict['string'] = string
return dict
def test_colorize_uux_ggg(self):
"""Test the colorize function for uu~ > ggg"""
myleglist = base_objects.LegList()
myleglist.append(base_objects.Leg({'id': 2, 'state': False}))
myleglist.append(base_objects.Leg({'id': -2, 'state': False}))
myleglist.extend([base_objects.Leg({'id': 21, 'state': True})] * 3)
myprocess = base_objects.Process({
'legs': myleglist,
'model': self.mymodel
})
myamplitude = diagram_generation.Amplitude()
myamplitude.set('process', myprocess)
myamplitude.generate_diagrams()
my_col_basis = color_amp.ColorBasis()
# First diagram with two 3-gluon vertices
col_dict = my_col_basis.colorize(myamplitude['diagrams'][0],
self.mymodel)
goal_dict = {
(0, 0, 0):
color.ColorString([
color.T(-1000, 2, 1),
color.f(-1001, 3, 4),
color.f(-1000, -1001, 5)
])
}
self.assertEqual(col_dict, goal_dict)
# Diagram with one 4-gluon vertex
col_dict = my_col_basis.colorize(myamplitude['diagrams'][3],
self.mymodel)
goal_dict = {
(0, 0):
color.ColorString([
color.T(-1000, 2, 1),
color.f(-1001, 3, 5),
color.f(-1001, 4, -1000)
]),
(0, 1):
color.ColorString([
color.T(-1000, 2, 1),
color.f(-1002, 3, -1000),
color.f(-1002, 4, 5)
]),
(0, 2):
color.ColorString([
color.T(-1000, 2, 1),
color.f(-1003, 3, 4),
color.f(-1003, 5, -1000)
])
}
self.assertEqual(col_dict, goal_dict)
def test_colorize_funny_model(self):
"""Test the colorize function for uu~ > ggg"""
mypartlist = base_objects.ParticleList()
myinterlist = base_objects.InteractionList()
mymodel = base_objects.Model()
# A gluon
mypartlist.append(
base_objects.Particle({
'name': 'g',
'antiname': 'g',
'spin': 3,
'color': 8,
'mass': 'zero',
'width': 'zero',
'texname': 'g',
'antitexname': 'g',
'line': 'curly',
'charge': 0.,
'pdg_code': 21,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
# 3 gluon vertiex
myinterlist.append(base_objects.Interaction({
'id': 1,
'particles': base_objects.ParticleList(\
[mypartlist[0]] * 3),
'color': [color.ColorString([color.f(0, 1, 2)]),
color.ColorString([color.f(0, 2, 1)]),
color.ColorString([color.f(1, 2, 0)])],
'lorentz':['L1'],
'couplings':{(0, 0):'G', (2,0):'G'},
'orders':{'QCD':1}}))
mymodel.set('particles', mypartlist)
mymodel.set('interactions', myinterlist)
myleglist = base_objects.LegList()
myleglist.append(base_objects.Leg({'id': 21, 'state': False}))
myleglist.append(base_objects.Leg({'id': 21, 'state': False}))
myleglist.extend([base_objects.Leg({'id': 21, 'state': True})] * 2)
myprocess = base_objects.Process({'legs': myleglist, 'model': mymodel})
myamplitude = diagram_generation.Amplitude()
myamplitude.set('process', myprocess)
myamplitude.generate_diagrams()
my_col_basis = color_amp.ColorBasis()
# Check that only the color structures that are actually used are included
col_dict = my_col_basis.colorize(myamplitude['diagrams'][0], mymodel)
goal_dict = {
(2, 0):
color.ColorString([color.f(1, 2, -1000),
color.f(3, 4, -1000)]),
(0, 0):
color.ColorString([color.f(-1000, 1, 2),
color.f(3, 4, -1000)]),
(0, 2):
color.ColorString([color.f(-1000, 1, 2),
color.f(4, -1000, 3)]),
(2, 2):
color.ColorString([color.f(1, 2, -1000),
color.f(4, -1000, 3)])
}
self.assertEqual(col_dict, goal_dict)
def setUp(self):
# A gluon
self.mypartlist.append(
base_objects.Particle({
'name': 'g',
'antiname': 'g',
'spin': 3,
'color': 8,
'mass': 'zero',
'width': 'zero',
'texname': 'g',
'antitexname': 'g',
'line': 'curly',
'charge': 0.,
'pdg_code': 21,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
# A quark U and its antiparticle
self.mypartlist.append(
base_objects.Particle({
'name': 'u',
'antiname': 'u~',
'spin': 2,
'color': 3,
'mass': 'zero',
'width': 'zero',
'texname': 'u',
'antitexname': '\bar u',
'line': 'straight',
'charge': 2. / 3.,
'pdg_code': 2,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
antiu = copy.copy(self.mypartlist[1])
antiu.set('is_part', False)
# A quark D and its antiparticle
self.mypartlist.append(
base_objects.Particle({
'name': 'd',
'antiname': 'd~',
'spin': 2,
'color': 3,
'mass': 'zero',
'width': 'zero',
'texname': 'u',
'antitexname': '\bar u',
'line': 'straight',
'charge': -1. / 3.,
'pdg_code': 1,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
antid = copy.copy(self.mypartlist[2])
antid.set('is_part', False)
# 3 gluon vertiex
self.myinterlist.append(base_objects.Interaction({
'id': 1,
'particles': base_objects.ParticleList(\
[self.mypartlist[0]] * 3),
'color': [color.ColorString([color.f(0, 1, 2)])],
'lorentz':['L1'],
'couplings':{(0, 0):'G'},
'orders':{'QCD':1}}))
# 4 gluon vertex
self.myinterlist.append(base_objects.Interaction({
'id': 2,
'particles': base_objects.ParticleList(\
[self.mypartlist[0]] * 4),
'color': [color.ColorString([color.f(-1, 0, 2),
color.f(-1, 1, 3)]),
color.ColorString([color.f(-1, 0, 3),
color.f(-1, 1, 2)]),
color.ColorString([color.f(-1, 0, 1),
color.f(-1, 2, 3)])],
'lorentz':['L(p1,p2,p3)', 'L(p2,p3,p1)', 'L3'],
'couplings':{(0, 0):'G^2',
(1, 1):'G^2',
(2, 2):'G^2'},
'orders':{'QCD':2}}))
# Gluon couplings to up and down quarks
self.myinterlist.append(base_objects.Interaction({
'id': 3,
'particles': base_objects.ParticleList(\
[self.mypartlist[1], \
antiu, \
self.mypartlist[0]]),
'color': [color.ColorString([color.T(2, 0, 1)])],
'lorentz':['L1'],
'couplings':{(0, 0):'GQQ'},
'orders':{'QCD':1}}))
self.myinterlist.append(base_objects.Interaction({
'id': 4,
'particles': base_objects.ParticleList(\
[self.mypartlist[2], \
antid, \
self.mypartlist[0]]),
'color': [color.ColorString([color.T(2, 0, 1)])],
'lorentz':['L1'],
'couplings':{(0, 0):'GQQ'},
'orders':{'QCD':1}}))
self.mymodel.set('particles', self.mypartlist)
self.mymodel.set('interactions', self.myinterlist)
