def test_mssm_equivalence(self):
"""Test the UFO and MG4 MSSM model correspond to the same model """
# import UFO model
mssm_path = import_ufo.find_ufo_path('MSSM_SLHA2')
ufo_model = import_ufo.import_model(mssm_path)
#converter = import_ufo.UFOMG5Converter(model)
#ufo_model = converter.load_model()
ufo_model.pass_particles_name_in_mg_default()
# import MG4 model
model = base_objects.Model()
if not MG4DIR:
raise MadGraph5Error("Please provide a valid MG/ME path with -d")
v4_path = os.path.join(MG4DIR, 'models', 'mssm_v4')
if not os.path.isdir(v4_path):
import_ufo.import_model_from_db('mssm_v4', local_dir=True)
model.set('particles', files.read_from_file(
os.path.join(v4_path,'particles.dat'),
import_v4.read_particles_v4))
model.set('interactions', files.read_from_file(
os.path.join(v4_path,'interactions.dat'),
import_v4.read_interactions_v4,
model['particles']))
#model.pass_particles_name_in_mg_default()
# Checking the particles
for particle in model['particles']:
ufo_particle = ufo_model.get("particle_dict")[particle['pdg_code']]
self.check_particles(particle, ufo_particle)
# Skip test below until equivalence has been created by Benj and Claude
return
# Checking the interactions
nb_vertex = 0
ufo_vertices = []
for ufo_vertex in ufo_model['interactions']:
pdg_code_ufo = [abs(part['pdg_code']) for part in ufo_vertex['particles']]
int_name = [part['name'] for part in ufo_vertex['particles']]
rep = (pdg_code_ufo, int_name)
pdg_code_ufo.sort()
ufo_vertices.append(pdg_code_ufo)
mg4_vertices = []
for vertex in model['interactions']:
pdg_code_mg4 = [abs(part['pdg_code']) for part in vertex['particles']]
pdg_code_mg4.sort()
try:
ufo_vertices.remove(pdg_code_mg4)
except ValueError:
mg4_vertices.append(pdg_code_mg4)
self.assertEqual(ufo_vertices, [])
self.assertEqual(mg4_vertices, [])
def test_sm_equivalence(self):
"""Test the UFO and MG4 SM model correspond to the same model """
# import UFO model
sm_path = import_ufo.find_ufo_path('sm')
ufo_model = import_ufo.import_model(sm_path)
ufo_model.pass_particles_name_in_mg_default()
# import MG4 model
model = base_objects.Model()
v4_path = os.path.join(MG4DIR, 'models', 'sm_v4')
if not os.path.isdir(v4_path):
v4_path = os.path.join(MG4DIR, 'Models', 'sm')
if not os.path.isdir(v4_path):
raise MadGraph5Error, \
"Please provide a valid MG/ME path with -d"
model.set(
'particles',
files.read_from_file(os.path.join(v4_path, 'particles.dat'),
import_v4.read_particles_v4))
model.set(
'interactions',
files.read_from_file(os.path.join(v4_path, 'interactions.dat'),
import_v4.read_interactions_v4,
model['particles']))
model.pass_particles_name_in_mg_default()
# Checking the particles
for particle in model['particles']:
ufo_particle = ufo_model.get("particle_dict")[particle['pdg_code']]
self.check_particles(particle, ufo_particle)
# Checking the interactions
nb_vertex = 0
ufo_vertices = []
for ufo_vertex in ufo_model['interactions']:
pdg_code_ufo = [
abs(part['pdg_code']) for part in ufo_vertex['particles']
]
int_name = [part['name'] for part in ufo_vertex['particles']]
rep = (pdg_code_ufo, int_name)
pdg_code_ufo.sort()
ufo_vertices.append(pdg_code_ufo)
mg4_vertices = []
for vertex in model['interactions']:
pdg_code_mg4 = [
abs(part['pdg_code']) for part in vertex['particles']
]
pdg_code_mg4.sort()
try:
ufo_vertices.remove(pdg_code_mg4)
except ValueError:
mg4_vertices.append(pdg_code_mg4)
self.assertEqual(ufo_vertices, [[25, 25, 25, 25]])
self.assertEqual(mg4_vertices, [])
def import_model(model_path, mgme_dir=MG4DIR, absolute=True):
"""create a model from a MG4 model directory."""
# Check for a valid directory
model_path_old = model_path
model_path = find_model_path(model_path, mgme_dir, absolute)
files_list = [os.path.join(model_path, 'particles.dat'),\
os.path.join(model_path, 'interactions.dat')]
for filepath in files_list:
if not os.path.isfile(filepath):
if not absolute:
raise InvalidCmd, "%s directory is not a valid v4 model" % \
(model_path)
else:
return import_model(model_path_old, mgme_dir, False)
# use pickle files if defined
if files.is_uptodate(os.path.join(model_path, 'model.pkl'), files_list):
model = save_load_object.load_from_file( \
os.path.join(model_path, 'model.pkl'))
if model.has_key('version_tag') and model.get(
'version_tag') == os.path.realpath(model_path) + str(
misc.get_pkg_info()):
return model, model_path
model = base_objects.Model()
model.set('particles',files.read_from_file( \
os.path.join(model_path, 'particles.dat'),
read_particles_v4))
model.set('interactions',files.read_from_file( \
os.path.join(model_path, 'interactions.dat'),
read_interactions_v4,
model['particles']))
model.set('name', os.path.split(model_path)[-1])
# save in a pickle files to fasten future usage
if ReadWrite:
try:
save_load_object.save_to_file(
os.path.join(model_path, 'model.pkl'), model)
except Exception:
logger.warning("fail to write %s. This is perfectly fine will just prevent speed boost in future load of this model" %\
os.path.join(model_path, 'model.pkl'))
return model, model_path
def setUp(self):
""" open the proc_card and initialize the object"""
v4proccard_file = open(os.path.join(_file_path, os.path.pardir, 'input_files', \
'v4_proc_card.dat'))
self.proccard = import_v4.ProcCardv4Reader(v4proccard_file)
# First define a valid model for Standard Model
model = base_objects.Model()
# Import Particles information
input_path = os.path.join(_file_path, '../input_files/v4_sm_particles.dat')
model.set('particles', files.read_from_file(input_path,
import_v4.read_particles_v4))
# Import Interaction information
input_path = os.path.join(_file_path , '../input_files/v4_sm_interactions.dat')
model.set('interactions', files.read_from_file(input_path, \
import_v4.read_interactions_v4, \
model.get('particles')))
self.model = model
class LoopDiagramDrawerTest(unittest.TestCase):
"""Test class for all functions related to the LoopDiagramDrawer
diagram made by hand
"""
myloopmodel = loop_base_objects.LoopModel()
mypartlist = base_objects.ParticleList()
myinterlist = base_objects.InteractionList()
mymodel = base_objects.Model()
myproc = base_objects.Process()
def setUp(self):
""" Setup a toy-model with gluon and down-quark only """
# 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 D and its antiparticle
self.mypartlist.append(
base_objects.Particle({
'name': 'd',
'antiname': 'd~',
'spin': 2,
'color': 3,
'mass': 'dmass',
'width': 'zero',
'texname': 'd',
'antitexname': '\bar d',
'line': 'straight',
'charge': -1. / 3.,
'pdg_code': 1,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
antid = copy.copy(self.mypartlist[1])
antid.set('is_part', False)
# 3 gluon vertex
self.myinterlist.append(base_objects.Interaction({
'id': 1,
'particles': base_objects.ParticleList(\
[self.mypartlist[0]] * 3),
'color': [],
'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': [],
'lorentz':['L1'],
'couplings':{(0, 0):'G^2'},
'orders':{'QCD':2}}))
# Gluon coupling to the down-quark
self.myinterlist.append(base_objects.Interaction({
'id': 3,
'particles': base_objects.ParticleList(\
[self.mypartlist[1], \
antid, \
self.mypartlist[0]]),
'color': [],
'lorentz':['L1'],
'couplings':{(0, 0):'GQQ'},
'orders':{'QCD':1}}))
self.mymodel.set('particles', self.mypartlist)
self.mymodel.set('interactions', self.myinterlist)
self.myproc.set('model', self.mymodel)
self.myloopmodel = save_load_object.load_from_file(os.path.join(_input_file_path,\
'test_toyLoopModel.pkl'))
box_diagram, box_struct = self.def_box()
pent_diagram, pent_struct = self.def_pent()
self.box_drawing = draw_lib.LoopFeynmanDiagram(box_diagram, box_struct,
self.myloopmodel)
def test_fuse_line(self):
""" check that we fuse line correctly """
self.box_drawing.load_diagram()
#avoid that element are erase from memory
line1 = self.box_drawing.lineList[0]
line2 = self.box_drawing.lineList[1]
vertex1 = line1.begin
vertex2 = line1.end
vertex3 = line2.begin
vertex4 = line2.end
# fuse line1 and line2
self.box_drawing.fuse_line(line1, line2)
# check that all link to line1 are ok
self.assertEqual(line1.begin, vertex1)
self.assertEqual(line1.end, vertex3)
self.assertTrue(line1 in vertex1.lines)
self.assertTrue(line1 in vertex3.lines)
#self.assertTrue(vertex1 in self.box_drawing.vertexList)
#self.assertTrue(vertex4 in self.box_drawing.vertexList)
#check that all info to line2 are deleted
self.assertFalse(line2 in self.box_drawing.lineList)
self.assertFalse(line2 in vertex1.lines)
self.assertFalse(line2 in vertex3.lines)
self.assertFalse(vertex2 in self.box_drawing.vertexList)
self.assertFalse(vertex3 in self.box_drawing.vertexList)
def def_box(self):
""" Test the drawing of a simple loop box """
myleglist = base_objects.LegList([base_objects.Leg({'id':21,
'number':num, 'state':True,
'loop_line':False}) \
for num in range(1, 5)])
myleglist.append(
base_objects.Leg({
'id': 1,
'number': 5,
'loop_line': True
}))
myleglist.append(
base_objects.Leg({
'id': -1,
'number': 6,
'loop_line': True
}))
l1 = myleglist[0]
l1.set('state', False)
l2 = myleglist[1]
l2.set('state', False)
l3 = myleglist[2]
l4 = myleglist[3]
l5 = myleglist[4]
l6 = myleglist[5]
# One way of constructing this diagram, with a three-point amplitude
l15 = base_objects.Leg({
'id': 1,
'number': 1,
'loop_line': True,
'state': False
})
l12 = base_objects.Leg({'id': 1, 'number': 1, 'loop_line': True})
l13 = base_objects.Leg({'id': 1, 'number': 1, 'loop_line': True})
lfake = base_objects.Leg({'id': 1, 'number': 1, 'loop_line': True})
vx15 = base_objects.Vertex({
'legs': base_objects.LegList([l1, l5, l15]),
'id': 3
})
vx12 = base_objects.Vertex({
'legs': base_objects.LegList([l15, l2, l12]),
'id': 3
})
vx13 = base_objects.Vertex({
'legs': base_objects.LegList([l12, l3, l13]),
'id': 3
})
vx164 = base_objects.Vertex({
'legs': base_objects.LegList([l13, l6, l4]),
'id': 3
})
fakevx = base_objects.Vertex({
'legs': base_objects.LegList([l13, lfake]),
'id': 0
})
ctvx = base_objects.Vertex({
'legs':
base_objects.LegList([l1, l2, l3, l4]),
'id':
666
})
myVertexList1 = base_objects.VertexList([vx15, vx12, vx13, vx164])
myCTVertexList = base_objects.VertexList([
ctvx,
])
myPentaDiag1=loop_base_objects.LoopDiagram({'vertices':myVertexList1,'type':1,\
'CT_vertices':myCTVertexList})
return myPentaDiag1, []
def def_pent(self):
""" Test the gg>gggg d*dx* tagging of a quark pentagon which is tagged"""
# Five gluon legs with two initial states
myleglist = base_objects.LegList([base_objects.Leg({'id':21,
'number':num,
'loop_line':False}) \
for num in range(1, 7)])
myleglist.append(
base_objects.Leg({
'id': 1,
'number': 7,
'loop_line': True
}))
myleglist.append(
base_objects.Leg({
'id': -1,
'number': 8,
'loop_line': True
}))
l1 = myleglist[0]
l2 = myleglist[1]
l3 = myleglist[2]
l4 = myleglist[3]
l5 = myleglist[4]
l6 = myleglist[5]
l7 = myleglist[6]
l8 = myleglist[7]
# One way of constructing this diagram, with a three-point amplitude
l17 = base_objects.Leg({'id': 1, 'number': 1, 'loop_line': True})
l12 = base_objects.Leg({'id': 1, 'number': 1, 'loop_line': True})
l68 = base_objects.Leg({'id': -1, 'number': 6, 'loop_line': True})
l56 = base_objects.Leg({'id': -1, 'number': 5, 'loop_line': True})
l34 = base_objects.Leg({'id': 21, 'number': 3, 'loop_line': False})
self.myproc.set('legs', myleglist)
vx17 = base_objects.Vertex({
'legs': base_objects.LegList([l1, l7, l17]),
'id': 3
})
vx12 = base_objects.Vertex({
'legs': base_objects.LegList([l17, l2, l12]),
'id': 3
})
vx68 = base_objects.Vertex({
'legs': base_objects.LegList([l6, l8, l68]),
'id': 3
})
vx56 = base_objects.Vertex({
'legs': base_objects.LegList([l5, l68, l56]),
'id': 3
})
vx34 = base_objects.Vertex({
'legs': base_objects.LegList([l3, l4, l34]),
'id': 1
})
vx135 = base_objects.Vertex({
'legs':
base_objects.LegList([l12, l56, l34]),
'id':
3
})
myVertexList1 = base_objects.VertexList(
[vx17, vx12, vx68, vx56, vx34, vx135])
myPentaDiag1 = loop_base_objects.LoopDiagram({
'vertices': myVertexList1,
'type': 1
})
myStructRep = loop_base_objects.FDStructureList()
myPentaDiag1.tag(myStructRep, self.myproc['model'], 7, 8)
return myPentaDiag1, myStructRep
# test the drawing of myPentaDiag with its loop vertices and those in the
# structures of myStructRep
def def_diagrams_epemddx(self):
""" Test the drawing of diagrams from the loop process e+e- > dd~ """
myleglist = base_objects.LegList()
myleglist.append(base_objects.Leg({'id': -11, 'state': False}))
myleglist.append(base_objects.Leg({'id': 11, 'state': False}))
myleglist.append(base_objects.Leg({'id': 1, 'state': True}))
myleglist.append(base_objects.Leg({'id': -1, 'state': True}))
myproc = base_objects.Process({
'legs': myleglist,
'model': self.myloopmodel,
'orders': {},
'perturbation_couplings': [
'QCD',
],
'squared_orders': {}
})
myloopamplitude = loop_diagram_generation.LoopAmplitude()
myloopamplitude.set('process', myproc)
myloopamplitude.generate_diagrams()
# Now the drawing test on myloopamplitude['loop_diagrams']
return myloopamplitude['loop_diagrams']
class UFOHELASCallWriterTest(unittest.TestCase):
"""Test class for the FortranHelasCallWriterTest object"""
mybasemodel = base_objects.Model()
def setUp(self):
# Set up model
mypartlist = base_objects.ParticleList()
myinterlist = base_objects.InteractionList()
# A photon
mypartlist.append(
base_objects.Particle({
'name': 'a',
'antiname': 'a',
'spin': 3,
'color': 1,
'mass': 'zero',
'width': 'zero',
'texname': '\gamma',
'antitexname': '\gamma',
'line': 'wavy',
'charge': 0.,
'pdg_code': 22,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
a = mypartlist[len(mypartlist) - 1]
# W+ and W-
mypartlist.append(
base_objects.Particle({
'name': 'w+',
'antiname': 'w-',
'spin': 3,
'color': 1,
'mass': 'wmas',
'width': 'wwid',
'texname': 'W^+',
'antitexname': 'W^-',
'line': 'wavy',
'charge': 1.,
'pdg_code': 24,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
wplus = mypartlist[len(mypartlist) - 1]
wminus = copy.copy(wplus)
wminus.set('is_part', False)
# Z
mypartlist.append(
base_objects.Particle({
'name': 'z',
'antiname': 'z',
'spin': 3,
'color': 1,
'mass': 'zmas',
'width': 'zwid',
'texname': 'Z',
'antitexname': 'Z',
'line': 'wavy',
'charge': 1.,
'pdg_code': 23,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
z = mypartlist[len(mypartlist) - 1]
# a-a-w+w- 4-vertex
myinterlist.append(base_objects.Interaction({
'id': 1,
'particles': base_objects.ParticleList(\
[a, \
a,
wminus,
wplus]),
'color': [],
'lorentz':['VVVV1'],
'couplings':{(0, 0):'GC_51'},
'orders':{'QED':2}}))
# w+w-z vertex
myinterlist.append(base_objects.Interaction({
'id': 2,
'particles': base_objects.ParticleList(\
[wminus,
wplus,
z]),
'color': [],
'lorentz':['VVV1'],
'couplings':{(0, 0):'GC_12'},
'orders':{'QED':1}}))
self.mybasemodel.set('particles', mypartlist)
self.mybasemodel.set('interactions', myinterlist)
self.mybasemodel.set('name', 'sm')
#import madgraph.interface.cmd_interface as cmd
#CMD = cmd.MadGraphCmdShell()
#CMD._curr_model = self.mybasemodel
#CMD._curr_fortran_model = helas_call_writers.FortranUFOHelasCallWriter
#CMD.do_generate('a w- > w- a z')
#CMD.do_export('matrix_v4 /tmp/')
leg1 = base_objects.Leg({'id': 22, 'state': False})
leg2 = base_objects.Leg({'id': 24, 'state': False})
leg3 = base_objects.Leg({'id': 22, 'state': True})
leg4 = base_objects.Leg({'id': 24, 'state': True})
leg5 = base_objects.Leg({'id': 23, 'state': True})
legList1 = base_objects.LegList([leg1, leg2, leg3, leg4, leg5])
myproc = base_objects.Process({
'legs': legList1,
'model': self.mybasemodel
})
myamplitude = diagram_generation.Amplitude({'process': myproc})
self.mymatrixelement = helas_objects.HelasMatrixElement(myamplitude)
def test_UFO_fortran_helas_call_writer(self):
"""Test automatic generation of UFO helas calls in Fortran"""
fortran_model = helas_call_writers.FortranUFOHelasCallWriter(\
self.mybasemodel)
result = fortran_model.get_matrix_element_calls(self.mymatrixelement)
solution = [
'CALL VXXXXX(P(0,1),zero,NHEL(1),-1*IC(1),W(1,1))',
'CALL VXXXXX(P(0,2),wmas,NHEL(2),-1*IC(2),W(1,2))',
'CALL VXXXXX(P(0,3),zero,NHEL(3),+1*IC(3),W(1,3))',
'CALL VXXXXX(P(0,4),wmas,NHEL(4),+1*IC(4),W(1,4))',
'CALL VXXXXX(P(0,5),zmas,NHEL(5),+1*IC(5),W(1,5))',
'CALL VVVV1_4(W(1,1),W(1,3),W(1,2),GC_51,wmas,wwid,W(1,6))',
'# Amplitude(s) for diagram number 1',
'CALL VVV1_0(W(1,6),W(1,4),W(1,5),GC_12,AMP(1))',
'CALL VVVV1_3(W(1,1),W(1,3),W(1,4),GC_51,wmas,wwid,W(1,6))',
'# Amplitude(s) for diagram number 2',
'CALL VVV1_0(W(1,2),W(1,6),W(1,5),GC_12,AMP(2))'
]
for i, line in enumerate(solution):
self.assertEqual(line, result[i])
def test_UFO_CPP_helas_call_writer(self):
"""Test automatic generation of UFO helas calls in C++"""
cpp_model = helas_call_writers.CPPUFOHelasCallWriter(\
self.mybasemodel)
result = cpp_model.get_matrix_element_calls(self.mymatrixelement)
solution = [
'vxxxxx(p[perm[0]],mME[0],hel[0],-1,w[0]);',
'vxxxxx(p[perm[1]],mME[1],hel[1],-1,w[1]);',
'vxxxxx(p[perm[2]],mME[2],hel[2],+1,w[2]);',
'vxxxxx(p[perm[3]],mME[3],hel[3],+1,w[3]);',
'vxxxxx(p[perm[4]],mME[4],hel[4],+1,w[4]);',
'VVVV1_4(w[0],w[2],w[1],pars->GC_51,pars->wmas,pars->wwid,w[5]);',
'# Amplitude(s) for diagram number 1',
'VVV1_0(w[5],w[3],w[4],pars->GC_12,amp[0]);',
'VVVV1_3(w[0],w[2],w[3],pars->GC_51,pars->wmas,pars->wwid,w[5]);',
'# Amplitude(s) for diagram number 2',
'VVV1_0(w[1],w[5],w[4],pars->GC_12,amp[1]);'
]
for i, line in enumerate(solution):
self.assertEqual(line, result[i])
def test_UFO_Python_helas_call_writer(self):
"""Test automatic generation of UFO helas calls in Python"""
cpp_model = helas_call_writers.PythonUFOHelasCallWriter(\
self.mybasemodel)
result = cpp_model.get_matrix_element_calls(self.mymatrixelement)
solution = [
'w[0] = vxxxxx(p[0],zero,hel[0],-1)',
'w[1] = vxxxxx(p[1],wmas,hel[1],-1)',
'w[2] = vxxxxx(p[2],zero,hel[2],+1)',
'w[3] = vxxxxx(p[3],wmas,hel[3],+1)',
'w[4] = vxxxxx(p[4],zmas,hel[4],+1)',
'w[5]= VVVV1_4(w[0],w[2],w[1],GC_51,wmas,wwid)',
'# Amplitude(s) for diagram number 1',
'amp[0]= VVV1_0(w[5],w[3],w[4],GC_12)',
'w[5]= VVVV1_3(w[0],w[2],w[3],GC_51,wmas,wwid)',
'# Amplitude(s) for diagram number 2',
'amp[1]= VVV1_0(w[1],w[5],w[4],GC_12)'
]
for i, line in enumerate(solution):
self.assertEqual(line, result[i])
class HelasModelTestSetup(unittest.TestCase):
"""Test class for the HelasModel object"""
mymodel = helas_call_writers.HelasCallWriter()
mybasemodel = base_objects.Model()
def setUp(self):
# Set up model
mypartlist = base_objects.ParticleList()
myinterlist = base_objects.InteractionList()
# 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
}))
g = mypartlist[len(mypartlist) - 1]
# A quark U and its antiparticle
mypartlist.append(
base_objects.Particle({
'name': 'u',
'antiname': 'u~',
'spin': 2,
'color': 3,
'mass': 'mu',
'width': 'zero',
'texname': 'u',
'antitexname': '\bar u',
'line': 'straight',
'charge': 2. / 3.,
'pdg_code': 2,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
u = mypartlist[len(mypartlist) - 1]
antiu = copy.copy(u)
antiu.set('is_part', False)
# A quark D and its antiparticle
mypartlist.append(
base_objects.Particle({
'name': 'd',
'antiname': 'd~',
'spin': 2,
'color': 3,
'mass': 'mu',
'width': 'zero',
'texname': 'd',
'antitexname': '\bar d',
'line': 'straight',
'charge': -1. / 3.,
'pdg_code': 1,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
d = mypartlist[len(mypartlist) - 1]
antid = copy.copy(d)
antid.set('is_part', False)
# A electron and positron
mypartlist.append(
base_objects.Particle({
'name': 'e+',
'antiname': 'e-',
'spin': 2,
'color': 1,
'mass': 'me',
'width': 'zero',
'texname': 'e^+',
'antitexname': 'e^-',
'line': 'straight',
'charge': -1.,
'pdg_code': 11,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
eminus = mypartlist[len(mypartlist) - 1]
eplus = copy.copy(eminus)
eplus.set('is_part', False)
# A photon
mypartlist.append(
base_objects.Particle({
'name': 'a',
'antiname': 'a',
'spin': 3,
'color': 1,
'mass': 'zero',
'width': 'zero',
'texname': '\gamma',
'antitexname': '\gamma',
'line': 'wavy',
'charge': 0.,
'pdg_code': 22,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
a = mypartlist[len(mypartlist) - 1]
# A T particle
mypartlist.append(
base_objects.Particle({
'name': 'T1',
'antiname': 'T1',
'spin': 5,
'color': 1,
'mass': 'zero',
'width': 'zero',
'texname': 'T',
'antitexname': 'T',
'line': 'double',
'charge': 0.,
'pdg_code': 8000002,
'propagating': False,
'is_part': True,
'self_antipart': True
}))
T1 = mypartlist[len(mypartlist) - 1]
# A U squark and its antiparticle
mypartlist.append(
base_objects.Particle({
'name': 'su',
'antiname': 'su~',
'spin': 1,
'color': 3,
'mass': 'Musq2',
'width': 'Wusq2',
'texname': '\tilde u',
'antitexname': '\bar {\tilde u}',
'line': 'dashed',
'charge': 2. / 3.,
'pdg_code': 1000002,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
su = mypartlist[len(mypartlist) - 1]
antisu = copy.copy(su)
antisu.set('is_part', False)
# A E slepton and its antiparticle
mypartlist.append(
base_objects.Particle({
'name': 'sl2-',
'antiname': 'sl2+',
'spin': 1,
'color': 1,
'mass': 'Msl2',
'width': 'Wsl2',
'texname': '\tilde e^-',
'antitexname': '\tilde e^+',
'line': 'dashed',
'charge': 1.,
'pdg_code': 1000011,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
seminus = mypartlist[len(mypartlist) - 1]
seplus = copy.copy(seminus)
seplus.set('is_part', False)
# A neutralino
mypartlist.append(
base_objects.Particle({
'name': 'n1',
'antiname': 'n1',
'spin': 2,
'color': 1,
'mass': 'Mneu1',
'width': 'Wneu1',
'texname': '\chi_0^1',
'antitexname': '\chi_0^1',
'line': 'straight',
'charge': 0.,
'pdg_code': 1000022,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
n1 = mypartlist[len(mypartlist) - 1]
# W+ and W-
mypartlist.append(
base_objects.Particle({
'name': 'W+',
'antiname': 'W-',
'spin': 3,
'color': 1,
'mass': 'wmas',
'width': 'wwid',
'texname': 'W^+',
'antitexname': 'W^-',
'line': 'wavy',
'charge': 1.,
'pdg_code': 24,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
wplus = mypartlist[len(mypartlist) - 1]
wminus = copy.copy(u)
wminus.set('is_part', False)
# Z
mypartlist.append(
base_objects.Particle({
'name': 'Z',
'antiname': 'Z',
'spin': 3,
'color': 1,
'mass': 'zmas',
'width': 'zwid',
'texname': 'Z',
'antitexname': 'Z',
'line': 'wavy',
'charge': 1.,
'pdg_code': 23,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
z = mypartlist[len(mypartlist) - 1]
# Gluon and photon couplings to quarks
myinterlist.append(base_objects.Interaction({
'id': 3,
'particles': base_objects.ParticleList(\
[u, \
antiu, \
g]),
'color': [],
'lorentz':[''],
'couplings':{(0, 0):'GG'},
'orders':{'QCD':1}}))
myinterlist.append(base_objects.Interaction({
'id': 4,
'particles': base_objects.ParticleList(\
[d, \
antid, \
a]),
'color': [],
'lorentz':[''],
'couplings':{(0, 0):'MGVX15'},
'orders':{'QED':1}}))
myinterlist.append(base_objects.Interaction({
'id': 10,
'particles': base_objects.ParticleList(\
[d, \
antid, \
g]),
'color': [],
'lorentz':[''],
'couplings':{(0, 0):'GG'},
'orders':{'QCD':1}}))
myinterlist.append(base_objects.Interaction({
'id': 11,
'particles': base_objects.ParticleList(\
[u, \
antiu, \
a]),
'color': [],
'lorentz':[''],
'couplings':{(0, 0):'MGVX15'},
'orders':{'QED':1}}))
# Tgg coupling
myinterlist.append(base_objects.Interaction({
'id': 5,
'particles': base_objects.ParticleList(\
[g, \
g, \
T1]),
'color': [],
'lorentz':['A'],
'couplings':{(0, 0):'MGVX2'},
'orders':{'QCD':1}}))
# ggg coupling
myinterlist.append(base_objects.Interaction({
'id': 15,
'particles': base_objects.ParticleList(\
[g, \
g, \
g]),
'color': [],
'lorentz':[''],
'couplings':{(0, 0):'MGVX1'},
'orders':{'QCD':1}}))
# Coupling of e to gamma
myinterlist.append(base_objects.Interaction({
'id': 7,
'particles': base_objects.ParticleList(\
[eminus, \
eplus, \
a]),
'color': [],
'lorentz':[''],
'couplings':{(0, 0):'MGVX12'},
'orders':{'QED':1}}))
# Gluon coupling to su
myinterlist.append(base_objects.Interaction({
'id': 105,
'particles': base_objects.ParticleList(\
[g, \
su, \
antisu]),
'color': [],
'lorentz':[''],
'couplings':{(0, 0):'MGVX74'},
'orders':{'QCD':1}}))
# Coupling of n1 to u and su
myinterlist.append(base_objects.Interaction({
'id': 101,
'particles': base_objects.ParticleList(\
[n1, \
u, \
antisu]),
'color': [],
'lorentz':[''],
'couplings':{(0, 0):'MGVX570'},
'orders':{'QED':1}}))
myinterlist.append(base_objects.Interaction({
'id': 102,
'particles': base_objects.ParticleList(\
[antiu, \
n1, \
su]),
'color': [],
'lorentz':[''],
'couplings':{(0, 0):'MGVX575'},
'orders':{'QED':1}}))
# Coupling of n1 to e and se
myinterlist.append(base_objects.Interaction({
'id': 103,
'particles': base_objects.ParticleList(\
[n1, \
eminus, \
seplus]),
'color': [],
'lorentz':[''],
'couplings':{(0, 0):'MGVX350'},
'orders':{'QED':1}}))
myinterlist.append(base_objects.Interaction({
'id': 104,
'particles': base_objects.ParticleList(\
[eplus, \
n1, \
seminus]),
'color': [],
'lorentz':[''],
'couplings':{(0, 0):'MGVX494'},
'orders':{'QED':1}}))
# Coupling of n1 to z
myinterlist.append(base_objects.Interaction({
'id': 106,
'particles': base_objects.ParticleList(\
[n1, \
n1,
z]),
'color': [],
'lorentz':[''],
'couplings':{(0, 0):'GZN11'},
'orders':{'QED':1}}))
# g-gamma-su-subar coupling
myinterlist.append(base_objects.Interaction({
'id': 100,
'particles': base_objects.ParticleList(\
[a,
g,
su,
antisu]),
'color': [],
'lorentz':[''],
'couplings':{(0, 0):'MGVX89'},
'orders':{'QED':1, 'QCD':1}}))
# w+w-w+w- coupling
myinterlist.append(base_objects.Interaction({
'id': 8,
'particles': base_objects.ParticleList(\
[wplus,
wminus,
wplus,
wminus]),
'color': [],
'lorentz':[''],
'couplings':{(0, 0):'MGVX6'},
'orders':{'QED':2}}))
# w+w-zz coupling
myinterlist.append(base_objects.Interaction({
'id': 9,
'particles': base_objects.ParticleList(\
[wplus,
wminus,
z,
z]),
'color': [],
'lorentz':[''],
'couplings':{(0, 0):'MGVX8'},
'orders':{'QED':2}}))
self.mybasemodel.set('particles', mypartlist)
self.mybasemodel.set('interactions', myinterlist)
self.mybasemodel.set('name', 'sm')
self.mymodel.set('model', self.mybasemodel)
class IOExportPythonTest(unittest.TestCase):
"""Test class for the export v4 module"""
mymodel = base_objects.Model()
mymatrixelement = helas_objects.HelasMatrixElement()
def setUp(self):
# Set up model
mypartlist = base_objects.ParticleList()
myinterlist = base_objects.InteractionList()
# u and c quarkd and their antiparticles
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
}))
u = mypartlist[len(mypartlist) - 1]
antiu = copy.copy(u)
antiu.set('is_part', False)
mypartlist.append(
base_objects.Particle({
'name': 'c',
'antiname': 'c~',
'spin': 2,
'color': 3,
'mass': 'MC',
'width': 'ZERO',
'texname': 'c',
'antitexname': '\bar c',
'line': 'straight',
'charge': 2. / 3.,
'pdg_code': 4,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
c = mypartlist[len(mypartlist) - 1]
antic = copy.copy(c)
antic.set('is_part', False)
# 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
}))
g = mypartlist[len(mypartlist) - 1]
# A photon
mypartlist.append(
base_objects.Particle({
'name': 'Z',
'antiname': 'Z',
'spin': 3,
'color': 1,
'mass': 'MZ',
'width': 'WZ',
'texname': 'Z',
'antitexname': 'Z',
'line': 'wavy',
'charge': 0.,
'pdg_code': 23,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
z = mypartlist[len(mypartlist) - 1]
# Gluon couplings to quarks
myinterlist.append(base_objects.Interaction({
'id': 1,
'particles': base_objects.ParticleList(\
[antiu, \
u, \
g]),
'color': [color.ColorString([color.T(2, 1, 0)])],
'lorentz':['FFV1'],
'couplings':{(0, 0):'GC_10'},
'orders':{'QCD':1}}))
# Gamma couplings to quarks
myinterlist.append(base_objects.Interaction({
'id': 2,
'particles': base_objects.ParticleList(\
[antiu, \
u, \
z]),
'color': [color.ColorString([color.T(1, 0)])],
'lorentz':['FFV2', 'FFV5'],
'couplings':{(0,0): 'GC_35', (0,1): 'GC_47'},
'orders':{'QED':1}}))
self.mymodel.set('particles', mypartlist)
self.mymodel.set('interactions', myinterlist)
self.mymodel.set('name', 'sm')
self.mypythonmodel = helas_call_writers.PythonUFOHelasCallWriter(
self.mymodel)
myleglist = base_objects.LegList()
myleglist.append(base_objects.Leg({'id': 2, 'state': False}))
myleglist.append(base_objects.Leg({'id': -2, 'state': False}))
myleglist.append(base_objects.Leg({'id': 2, 'state': True}))
myleglist.append(base_objects.Leg({'id': -2, 'state': True}))
myproc = base_objects.Process({
'legs': myleglist,
'model': self.mymodel
})
myamplitude = diagram_generation.Amplitude({'process': myproc})
self.mymatrixelement = helas_objects.HelasMultiProcess(myamplitude)
myleglist = base_objects.LegList()
myleglist.append(
base_objects.Leg({
'id': 4,
'state': False,
'number': 1
}))
myleglist.append(
base_objects.Leg({
'id': -4,
'state': False,
'number': 2
}))
myleglist.append(
base_objects.Leg({
'id': 4,
'state': True,
'number': 3
}))
myleglist.append(
base_objects.Leg({
'id': -4,
'state': True,
'number': 4
}))
myproc = base_objects.Process({
'legs': myleglist,
'model': self.mymodel
})
self.mymatrixelement.get('matrix_elements')[0].\
get('processes').append(myproc)
self.exporter = export_python.ProcessExporterPython(\
self.mymatrixelement, self.mypythonmodel)
def test_python_export_functions(self):
"""Test functions used by the Python export"""
# Test the exporter setup
self.assertEqual(self.exporter.model, self.mymodel)
self.assertEqual(self.exporter.matrix_elements,
self.mymatrixelement.get('matrix_elements'))
def test_get_python_matrix_methods(self):
"""Test getting the matrix methods for Python for a matrix element."""
goal_method = (\
"""class Matrix_0_uux_uux(object):
def __init__(self):
\"\"\"define the object\"\"\"
self.clean()
def clean(self):
self.jamp = []
def smatrix(self,p, model):
#
# MadGraph5_aMC@NLO v. %(version)s, %(date)s
# By the MadGraph5_aMC@NLO Development Team
# Visit launchpad.net/madgraph5 and amcatnlo.web.cern.ch
#
# MadGraph5_aMC@NLO StandAlone Version
#
# Returns amplitude squared summed/avg over colors
# and helicities
# for the point in phase space P(0:3,NEXTERNAL)
#
# Process: u u~ > u u~
# Process: c c~ > c c~
#
# Clean additional output
#
self.clean()
#
# CONSTANTS
#
nexternal = 4
ndiags = 4
ncomb = 16
#
# LOCAL VARIABLES
#
helicities = [ \\
[-1,-1,-1,-1],
[-1,-1,-1,1],
[-1,-1,1,-1],
[-1,-1,1,1],
[-1,1,-1,-1],
[-1,1,-1,1],
[-1,1,1,-1],
[-1,1,1,1],
[1,-1,-1,-1],
[1,-1,-1,1],
[1,-1,1,-1],
[1,-1,1,1],
[1,1,-1,-1],
[1,1,-1,1],
[1,1,1,-1],
[1,1,1,1]]
denominator = 36
# ----------
# BEGIN CODE
# ----------
self.amp2 = [0.] * ndiags
self.helEvals = []
ans = 0.
for hel in helicities:
t = self.matrix(p, hel, model)
ans = ans + t
self.helEvals.append([hel, t.real / denominator ])
ans = ans / denominator
return ans.real
def matrix(self, p, hel, model):
#
# MadGraph5_aMC@NLO v. %(version)s, %(date)s
# By the MadGraph5_aMC@NLO Development Team
# Visit launchpad.net/madgraph5 and amcatnlo.web.cern.ch
#
# Returns amplitude squared summed/avg over colors
# for the point with external lines W(0:6,NEXTERNAL)
#
# Process: u u~ > u u~
# Process: c c~ > c c~
#
#
# Process parameters
#
ngraphs = 4
nexternal = 4
nwavefuncs = 5
ncolor = 2
ZERO = 0.
#
# Color matrix
#
denom = [1,1];
cf = [[9,3],
[3,9]];
#
# Model parameters
#
WZ = model.get('parameter_dict')["WZ"]
MZ = model.get('parameter_dict')["MZ"]
GC_47 = model.get('coupling_dict')["GC_47"]
GC_35 = model.get('coupling_dict')["GC_35"]
GC_10 = model.get('coupling_dict')["GC_10"]
# ----------
# Begin code
# ----------
amp = [None] * ngraphs
w = [None] * nwavefuncs
w[0] = ixxxxx(p[0],ZERO,hel[0],+1)
w[1] = oxxxxx(p[1],ZERO,hel[1],-1)
w[2] = oxxxxx(p[2],ZERO,hel[2],+1)
w[3] = ixxxxx(p[3],ZERO,hel[3],-1)
w[4]= FFV1_3(w[0],w[1],GC_10,ZERO,ZERO)
# Amplitude(s) for diagram number 1
amp[0]= FFV1_0(w[3],w[2],w[4],GC_10)
w[4]= FFV2_5_3(w[0],w[1],GC_35,GC_47,MZ,WZ)
# Amplitude(s) for diagram number 2
amp[1]= FFV2_5_0(w[3],w[2],w[4],GC_35,GC_47)
w[4]= FFV1_3(w[0],w[2],GC_10,ZERO,ZERO)
# Amplitude(s) for diagram number 3
amp[2]= FFV1_0(w[3],w[1],w[4],GC_10)
w[4]= FFV2_5_3(w[0],w[2],GC_35,GC_47,MZ,WZ)
# Amplitude(s) for diagram number 4
amp[3]= FFV2_5_0(w[3],w[1],w[4],GC_35,GC_47)
jamp = [None] * ncolor
jamp[0] = +1./6.*amp[0]-amp[1]+1./2.*amp[2]
jamp[1] = -1./2.*amp[0]-1./6.*amp[2]+amp[3]
self.amp2[0]+=abs(amp[0]*amp[0].conjugate())
self.amp2[1]+=abs(amp[1]*amp[1].conjugate())
self.amp2[2]+=abs(amp[2]*amp[2].conjugate())
self.amp2[3]+=abs(amp[3]*amp[3].conjugate())
matrix = 0.
for i in range(ncolor):
ztemp = 0
for j in range(ncolor):
ztemp = ztemp + cf[i][j]*jamp[j]
matrix = matrix + ztemp * jamp[i].conjugate()/denom[i]
self.jamp.append(jamp)
return matrix
""" % misc.get_pkg_info()).split('\n')
exporter = export_python.ProcessExporterPython(self.mymatrixelement,
self.mypythonmodel)
matrix_methods = exporter.get_python_matrix_methods()["0_uux_uux"].\
split('\n')
self.assertEqual(matrix_methods, goal_method)
def test_run_python_matrix_element(self):
"""Test a complete running of a Python matrix element without
writing any files"""
# Import the SM
sm_path = import_ufo.find_ufo_path('sm')
model = import_ufo.import_model(sm_path)
myleglist = base_objects.LegList()
myleglist.append(
base_objects.Leg({
'id': -11,
'state': False,
'number': 1
}))
myleglist.append(
base_objects.Leg({
'id': 11,
'state': False,
'number': 2
}))
myleglist.append(
base_objects.Leg({
'id': 22,
'state': True,
'number': 3
}))
myleglist.append(
base_objects.Leg({
'id': 22,
'state': True,
'number': 4
}))
myleglist.append(
base_objects.Leg({
'id': 22,
'state': True,
'number': 5
}))
myproc = base_objects.Process({'legs': myleglist, 'model': model})
myamplitude = diagram_generation.Amplitude({'process': myproc})
mymatrixelement = helas_objects.HelasMatrixElement(myamplitude)
# Create only the needed aloha routines
wanted_lorentz = mymatrixelement.get_used_lorentz()
aloha_model = create_aloha.AbstractALOHAModel(model.get('name'))
aloha_model.compute_subset(wanted_lorentz)
# Write out the routines in Python
aloha_routines = []
for routine in aloha_model.values():
aloha_routines.append(routine.write(output_dir = None,
language = 'Python').\
replace('import wavefunctions',
'import aloha.template_files.wavefunctions as wavefunctions'))
# Define the routines to be available globally
for routine in aloha_routines:
exec(routine, globals())
# Write the matrix element(s) in Python
mypythonmodel = helas_call_writers.PythonUFOHelasCallWriter(\
model)
exporter = export_python.ProcessExporterPython(\
mymatrixelement,
mypythonmodel)
matrix_methods = exporter.get_python_matrix_methods()
# Calculate parameters and couplings
full_model = model_reader.ModelReader(model)
full_model.set_parameters_and_couplings()
# Define a momentum
p = [[
0.5000000e+03, 0.0000000e+00, 0.0000000e+00, 0.5000000e+03,
0.0000000e+00
],
[
0.5000000e+03, 0.0000000e+00, 0.0000000e+00, -0.5000000e+03,
0.0000000e+00
],
[
0.4585788e+03, 0.1694532e+03, 0.3796537e+03, -0.1935025e+03,
0.6607249e-05
],
[
0.3640666e+03, -0.1832987e+02, -0.3477043e+03, 0.1063496e+03,
0.7979012e-05
],
[
0.1773546e+03, -0.1511234e+03, -0.3194936e+02, 0.8715287e+02,
0.1348699e-05
]]
# Evaluate the matrix element for the given momenta
answer = 1.39189717257175028e-007
for process in matrix_methods.keys():
# Define Python matrix element for process
exec(matrix_methods[process])
# Calculate the matrix element for the momentum p
value = eval("Matrix_0_epem_aaa().smatrix(p, full_model)")
self.assertTrue(abs(value-answer)/answer < 1e-6,
"Value is: %.9e should be %.9e" % \
(abs(value), answer))
def test_export_matrix_element_python_madevent_group(self):
"""Test the result of exporting a subprocess group matrix element"""
# Setup a model
mypartlist = base_objects.ParticleList()
myinterlist = base_objects.InteractionList()
# 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
}))
g = mypartlist[-1]
# A quark U and its antiparticle
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
}))
u = mypartlist[-1]
antiu = copy.copy(u)
antiu.set('is_part', False)
# A quark D and its antiparticle
mypartlist.append(
base_objects.Particle({
'name': 'd',
'antiname': 'd~',
'spin': 2,
'color': 3,
'mass': 'zero',
'width': 'zero',
'texname': 'd',
'antitexname': '\bar d',
'line': 'straight',
'charge': -1. / 3.,
'pdg_code': 1,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
d = mypartlist[-1]
antid = copy.copy(d)
antid.set('is_part', False)
# A photon
mypartlist.append(
base_objects.Particle({
'name': 'a',
'antiname': 'a',
'spin': 3,
'color': 1,
'mass': 'zero',
'width': 'zero',
'texname': '\gamma',
'antitexname': '\gamma',
'line': 'wavy',
'charge': 0.,
'pdg_code': 22,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
a = mypartlist[-1]
# A Z
mypartlist.append(
base_objects.Particle({
'name': 'z',
'antiname': 'z',
'spin': 3,
'color': 1,
'mass': 'MZ',
'width': 'WZ',
'texname': 'Z',
'antitexname': 'Z',
'line': 'wavy',
'charge': 0.,
'pdg_code': 23,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
z = mypartlist[-1]
# Gluon and photon couplings to quarks
myinterlist.append(base_objects.Interaction({
'id': 1,
'particles': base_objects.ParticleList(\
[antiu, \
u, \
g]),
'color': [],
'lorentz':['L1'],
'couplings':{(0, 0):'GQQ'},
'orders':{'QCD':1}}))
myinterlist.append(base_objects.Interaction({
'id': 2,
'particles': base_objects.ParticleList(\
[antiu, \
u, \
a]),
'color': [],
'lorentz':['L1'],
'couplings':{(0, 0):'GQED'},
'orders':{'QED':1}}))
myinterlist.append(base_objects.Interaction({
'id': 3,
'particles': base_objects.ParticleList(\
[antid, \
d, \
g]),
'color': [],
'lorentz':['L1'],
'couplings':{(0, 0):'GQQ'},
'orders':{'QCD':1}}))
myinterlist.append(base_objects.Interaction({
'id': 4,
'particles': base_objects.ParticleList(\
[antid, \
d, \
a]),
'color': [],
'lorentz':['L1'],
'couplings':{(0, 0):'GQED'},
'orders':{'QED':1}}))
# 3 gluon vertiex
myinterlist.append(base_objects.Interaction({
'id': 5,
'particles': base_objects.ParticleList(\
[g] * 3),
'color': [],
'lorentz':['L1'],
'couplings':{(0, 0):'G'},
'orders':{'QCD':1}}))
# Coupling of Z to quarks
myinterlist.append(base_objects.Interaction({
'id': 6,
'particles': base_objects.ParticleList(\
[antiu, \
u, \
z]),
'color': [],
'lorentz':['L1', 'L2'],
'couplings':{(0, 0):'GUZ1', (0, 1):'GUZ2'},
'orders':{'QED':1}}))
myinterlist.append(base_objects.Interaction({
'id': 7,
'particles': base_objects.ParticleList(\
[antid, \
d, \
z]),
'color': [],
'lorentz':['L1', 'L2'],
'couplings':{(0, 0):'GDZ1', (0, 0):'GDZ2'},
'orders':{'QED':1}}))
mymodel = base_objects.Model()
mymodel.set('particles', mypartlist)
mymodel.set('interactions', myinterlist)
procs = [[2, -2, 21, 21], [2, -2, 2, -2]]
amplitudes = diagram_generation.AmplitudeList()
for proc in procs:
# Define the multiprocess
my_leglist = base_objects.LegList([\
base_objects.Leg({'id': id, 'state': True}) for id in proc])
my_leglist[0].set('state', False)
my_leglist[1].set('state', False)
my_process = base_objects.Process({
'legs': my_leglist,
'model': mymodel
})
my_amplitude = diagram_generation.Amplitude(my_process)
amplitudes.append(my_amplitude)
# Calculate diagrams for all processes
subprocess_group = group_subprocs.SubProcessGroup.\
group_amplitudes(amplitudes, "madevent")[0]
# Test amp2 lines
helas_writer = helas_call_writers.PythonUFOHelasCallWriter(mymodel)
python_exporter = export_python.ProcessExporterPython(
subprocess_group, helas_writer)
amp2_lines = \
python_exporter.get_amp2_lines(subprocess_group.\
get('matrix_elements')[0],
subprocess_group.get('diagram_maps')[0])
self.assertEqual(amp2_lines, [
'self.amp2[0]+=abs(amp[0]*amp[0].conjugate())',
'self.amp2[1]+=abs(amp[1]*amp[1].conjugate())',
'self.amp2[2]+=abs(amp[2]*amp[2].conjugate())'
])
def test_export_matrix_element_python_madevent_group(self):
"""Test the result of exporting a subprocess group matrix element"""
# Setup a model
mypartlist = base_objects.ParticleList()
myinterlist = base_objects.InteractionList()
# 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
}))
g = mypartlist[-1]
# A quark U and its antiparticle
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
}))
u = mypartlist[-1]
antiu = copy.copy(u)
antiu.set('is_part', False)
# A quark D and its antiparticle
mypartlist.append(
base_objects.Particle({
'name': 'd',
'antiname': 'd~',
'spin': 2,
'color': 3,
'mass': 'zero',
'width': 'zero',
'texname': 'd',
'antitexname': '\bar d',
'line': 'straight',
'charge': -1. / 3.,
'pdg_code': 1,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
d = mypartlist[-1]
antid = copy.copy(d)
antid.set('is_part', False)
# A photon
mypartlist.append(
base_objects.Particle({
'name': 'a',
'antiname': 'a',
'spin': 3,
'color': 1,
'mass': 'zero',
'width': 'zero',
'texname': '\gamma',
'antitexname': '\gamma',
'line': 'wavy',
'charge': 0.,
'pdg_code': 22,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
a = mypartlist[-1]
# A Z
mypartlist.append(
base_objects.Particle({
'name': 'z',
'antiname': 'z',
'spin': 3,
'color': 1,
'mass': 'MZ',
'width': 'WZ',
'texname': 'Z',
'antitexname': 'Z',
'line': 'wavy',
'charge': 0.,
'pdg_code': 23,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
z = mypartlist[-1]
# Gluon and photon couplings to quarks
myinterlist.append(base_objects.Interaction({
'id': 1,
'particles': base_objects.ParticleList(\
[antiu, \
u, \
g]),
'color': [],
'lorentz':['L1'],
'couplings':{(0, 0):'GQQ'},
'orders':{'QCD':1}}))
myinterlist.append(base_objects.Interaction({
'id': 2,
'particles': base_objects.ParticleList(\
[antiu, \
u, \
a]),
'color': [],
'lorentz':['L1'],
'couplings':{(0, 0):'GQED'},
'orders':{'QED':1}}))
myinterlist.append(base_objects.Interaction({
'id': 3,
'particles': base_objects.ParticleList(\
[antid, \
d, \
g]),
'color': [],
'lorentz':['L1'],
'couplings':{(0, 0):'GQQ'},
'orders':{'QCD':1}}))
myinterlist.append(base_objects.Interaction({
'id': 4,
'particles': base_objects.ParticleList(\
[antid, \
d, \
a]),
'color': [],
'lorentz':['L1'],
'couplings':{(0, 0):'GQED'},
'orders':{'QED':1}}))
# 3 gluon vertiex
myinterlist.append(base_objects.Interaction({
'id': 5,
'particles': base_objects.ParticleList(\
[g] * 3),
'color': [],
'lorentz':['L1'],
'couplings':{(0, 0):'G'},
'orders':{'QCD':1}}))
# Coupling of Z to quarks
myinterlist.append(base_objects.Interaction({
'id': 6,
'particles': base_objects.ParticleList(\
[antiu, \
u, \
z]),
'color': [],
'lorentz':['L1', 'L2'],
'couplings':{(0, 0):'GUZ1', (0, 1):'GUZ2'},
'orders':{'QED':1}}))
myinterlist.append(base_objects.Interaction({
'id': 7,
'particles': base_objects.ParticleList(\
[antid, \
d, \
z]),
'color': [],
'lorentz':['L1', 'L2'],
'couplings':{(0, 0):'GDZ1', (0, 0):'GDZ2'},
'orders':{'QED':1}}))
mymodel = base_objects.Model()
mymodel.set('particles', mypartlist)
mymodel.set('interactions', myinterlist)
procs = [[2, -2, 21, 21], [2, -2, 2, -2]]
amplitudes = diagram_generation.AmplitudeList()
for proc in procs:
# Define the multiprocess
my_leglist = base_objects.LegList([\
base_objects.Leg({'id': id, 'state': True}) for id in proc])
my_leglist[0].set('state', False)
my_leglist[1].set('state', False)
my_process = base_objects.Process({
'legs': my_leglist,
'model': mymodel
})
my_amplitude = diagram_generation.Amplitude(my_process)
amplitudes.append(my_amplitude)
# Calculate diagrams for all processes
subprocess_group = group_subprocs.SubProcessGroup.\
group_amplitudes(amplitudes, "madevent")[0]
# Test amp2 lines
helas_writer = helas_call_writers.PythonUFOHelasCallWriter(mymodel)
python_exporter = export_python.ProcessExporterPython(
subprocess_group, helas_writer)
amp2_lines = \
python_exporter.get_amp2_lines(subprocess_group.\
get('matrix_elements')[0],
subprocess_group.get('diagram_maps')[0])
self.assertEqual(amp2_lines, [
'self.amp2[0]+=abs(amp[0]*amp[0].conjugate())',
'self.amp2[1]+=abs(amp[1]*amp[1].conjugate())',
'self.amp2[2]+=abs(amp[2]*amp[2].conjugate())'
])
class ColorSquareTest(unittest.TestCase):
"""Test class for the color_amp module"""
mypartlist = base_objects.ParticleList()
myinterlist = base_objects.InteractionList()
mymodel = base_objects.Model()
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_color_matrix_multi_gluons(self):
"""Test the color matrix building for gg > n*g with n up to 3"""
goal = [
fractions.Fraction(7, 3),
fractions.Fraction(19, 6),
fractions.Fraction(455, 108),
fractions.Fraction(3641, 648)
]
goal_line1 = [(fractions.Fraction(7, 3), fractions.Fraction(-2, 3)),
(fractions.Fraction(19, 6), fractions.Fraction(-1, 3),
fractions.Fraction(-1, 3), fractions.Fraction(-1, 3),
fractions.Fraction(-1, 3), fractions.Fraction(2, 3)),
(fractions.Fraction(455,
108), fractions.Fraction(-29, 54),
fractions.Fraction(-29, 54), fractions.Fraction(7, 54),
fractions.Fraction(7, 54), fractions.Fraction(17, 27),
fractions.Fraction(-29, 54), fractions.Fraction(-1, 27),
fractions.Fraction(7, 54), fractions.Fraction(-29, 54),
fractions.Fraction(5, 108), fractions.Fraction(-1, 27),
fractions.Fraction(7, 54), fractions.Fraction(5, 108),
fractions.Fraction(17, 27), fractions.Fraction(-1, 27),
fractions.Fraction(7, 54), fractions.Fraction(17, 27),
fractions.Fraction(-29, 54), fractions.Fraction(-1, 27),
fractions.Fraction(-1, 27), fractions.Fraction(17, 27),
fractions.Fraction(17, 27), fractions.Fraction(-10,
27))]
for n in range(3):
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
})] * (n + 1))
myprocess = base_objects.Process({
'legs': myleglist,
'model': self.mymodel
})
myamplitude = diagram_generation.Amplitude()
myamplitude.set('process', myprocess)
myamplitude.generate_diagrams()
col_basis = color_amp.ColorBasis(myamplitude)
col_matrix = color_amp.ColorMatrix(col_basis, Nc=3)
# Check diagonal
for i in range(len(col_basis.items())):
self.assertEqual(col_matrix.col_matrix_fixed_Nc[(i, i)],
(goal[n], 0))
# Check first line
for i in range(len(col_basis.items())):
self.assertEqual(col_matrix.col_matrix_fixed_Nc[(0, i)],
(goal_line1[n][i], 0))
def test_color_matrix_multi_quarks(self):
"""Test the color matrix building for qq~ > n*(qq~) with n up to 2"""
goal = [fractions.Fraction(9, 1), fractions.Fraction(27, 1)]
goal_line1 = [(fractions.Fraction(9, 1), fractions.Fraction(3, 1)),
(fractions.Fraction(27, 1), fractions.Fraction(9, 1),
fractions.Fraction(9, 1), fractions.Fraction(3, 1),
fractions.Fraction(3, 1), fractions.Fraction(9, 1))]
goal_den_list = [[1] * 2, [1] * 6]
goal_first_line_num = [[9, 3], [27, 9, 9, 3, 3, 9]]
for n in range(2):
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': -2,
'state': True
}),
base_objects.Leg({
'id': 2,
'state': True
})
] * (n + 1))
myprocess = base_objects.Process({
'legs': myleglist,
'model': self.mymodel
})
myamplitude = diagram_generation.Amplitude()
myamplitude.set('process', myprocess)
myamplitude.generate_diagrams()
col_basis = color_amp.ColorBasis(myamplitude)
col_matrix = color_amp.ColorMatrix(col_basis, Nc=3)
# Check diagonal
for i in range(len(col_basis.items())):
self.assertEqual(col_matrix.col_matrix_fixed_Nc[(i, i)],
(goal[n], 0))
# Check first line
for i in range(len(col_basis.items())):
self.assertEqual(col_matrix.col_matrix_fixed_Nc[(0, i)],
(goal_line1[n][i], 0))
self.assertEqual(col_matrix.get_line_denominators(),
goal_den_list[n])
self.assertEqual(
col_matrix.get_line_numerators(
0,
col_matrix.get_line_denominators()[0]),
goal_first_line_num[n])
def test_color_matrix_Nc_restrictions(self):
"""Test the Nc power restriction during color basis building """
goal = [
fractions.Fraction(3, 8),
fractions.Fraction(-9, 4),
fractions.Fraction(45, 16)
]
for n in range(3):
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': self.mymodel
})
myamplitude = diagram_generation.Amplitude()
myamplitude.set('process', myprocess)
myamplitude.generate_diagrams()
col_basis = color_amp.ColorBasis(myamplitude)
col_matrix = color_amp.ColorMatrix(col_basis,
Nc=3,
Nc_power_min=n,
Nc_power_max=2 * n)
for i in range(len(col_basis.items())):
self.assertEqual(col_matrix.col_matrix_fixed_Nc[(i, i)],
(goal[n], 0))
def test_color_matrix_fixed_indices(self):
"""Test index fixing for immutable color string"""
immutable1 = (('f', (1, -1, -3)), ('T', (-1, -3, 4)))
immutable2 = (('d', (1, -2, -1)), ('T', (-1, -2, 4)))
self.assertEqual(
color_amp.ColorMatrix.fix_summed_indices(immutable1, immutable2),
(('d', (1, -2, -5)), ('T', (-5, -2, 4))))
def test_helper_lcm_functions(self):
"""Test the helper functions to derive common denominators for
lines in the color matrix."""
self.assertEqual(color_amp.ColorMatrix.lcm(6, 3), 6)
self.assertEqual(color_amp.ColorMatrix.lcmm(6, 3, 5, 2), 30)
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)
class ColorAmpTest(unittest.TestCase):
"""Test class for the color_amp module"""
mypartlist = base_objects.ParticleList()
myinterlist = base_objects.InteractionList()
mymodel = base_objects.Model()
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)
# A photon
self.mypartlist.append(
base_objects.Particle({
'name': 'a',
'antiname': 'a',
'spin': 3,
'color': 1,
'mass': 'zero',
'width': 'zero',
'texname': '\gamma',
'antitexname': '\gamma',
'line': 'wavy',
'charge': 0.,
'pdg_code': 22,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
# A Higgs
self.mypartlist.append(
base_objects.Particle({
'name': 'h',
'antiname': 'h',
'spin': 1,
'color': 1,
'mass': 'mh',
'width': 'wh',
'texname': 'h',
'antitexname': 'h',
'line': 'dashed',
'charge': 0.,
'pdg_code': 25,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
# 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}}))
# Photon coupling to up
self.myinterlist.append(base_objects.Interaction({
'id': 5,
'particles': base_objects.ParticleList(\
[self.mypartlist[1], \
antiu, \
self.mypartlist[3]]),
'color': [color.ColorString([color.T(0, 1)])],
'lorentz':['L1'],
'couplings':{(0, 0):'GQED'},
'orders':{'QED':1}}))
self.mymodel.set('particles', self.mypartlist)
self.mymodel.set('interactions', self.myinterlist)
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_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 test_color_basis_uux_aggg(self):
"""Test the color basis building for uu~ > aggg (3! elements)"""
myleglist = base_objects.LegList()
myleglist.append(base_objects.Leg({'id': -2, 'state': False}))
myleglist.append(base_objects.Leg({'id': 2, 'state': False}))
myleglist.append(base_objects.Leg({'id': 22, 'state': True}))
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()
new_col_basis = color_amp.ColorBasis(myamplitude)
self.assertEqual(len(new_col_basis), 6)
# Test the color flow decomposition
self.assertEqual(
new_col_basis.color_flow_decomposition(
{
1: 3,
2: -3,
3: 1,
4: 8,
5: 8,
6: -8
}, 2), [{
1: [0, 501],
2: [504, 0],
3: [0, 0],
4: [502, 501],
5: [503, 502],
6: [504, 503]
}, {
1: [0, 501],
2: [503, 0],
3: [0, 0],
4: [502, 501],
5: [503, 504],
6: [504, 502]
}, {
1: [0, 501],
2: [504, 0],
3: [0, 0],
4: [502, 503],
5: [503, 501],
6: [504, 502]
}, {
1: [0, 501],
2: [502, 0],
3: [0, 0],
4: [502, 504],
5: [503, 501],
6: [504, 503]
}, {
1: [0, 501],
2: [503, 0],
3: [0, 0],
4: [502, 504],
5: [503, 502],
6: [504, 501]
}, {
1: [0, 501],
2: [502, 0],
3: [0, 0],
4: [502, 503],
5: [503, 504],
6: [504, 501]
}])
def test_color_flow_string(self):
"""Test the color flow decomposition of various color strings"""
# qq~>qq~
my_cs = color.ColorString([color.T(-1000, 1, 2), color.T(-1000, 3, 4)])
goal_cs = color.ColorString([color.T(1, 4), color.T(3, 2)])
goal_cs.coeff = fractions.Fraction(1, 2)
self.assertEqual(color_amp.ColorBasis.get_color_flow_string(my_cs, []),
goal_cs)
# qq~>qq~g
my_cs = color.ColorString(
[color.T(-1000, 1, 2),
color.T(-1000, 3, 4),
color.T(5, 4, 6)])
goal_cs = color.ColorString(
[color.T(1, 2005),
color.T(3, 2), color.T(1005, 6)])
goal_cs.coeff = fractions.Fraction(1, 4)
self.assertEqual(
color_amp.ColorBasis.get_color_flow_string(my_cs,
[(8, 5, 1005, 2005)]),
goal_cs)
# gg>gg
my_cs = color.ColorString(
[color.Tr(-1000, 1, 2),
color.Tr(-1000, 3, 4)])
goal_cs = color.ColorString([
color.T(1001, 2002),
color.T(1002, 2003),
color.T(1003, 2004),
color.T(1004, 2001)
])
goal_cs.coeff = fractions.Fraction(1, 32)
self.assertEqual(
color_amp.ColorBasis.get_color_flow_string(my_cs,
[(8, 1, 1001, 2001),
(8, 2, 1002, 2002),
(8, 3, 1003, 2003),
(8, 4, 1004, 2004)]),
goal_cs)
def test_color_flow_string_epsilon(self):
"""Test the color flow decomposition of strings including Epsilon
and color sextets"""
# g q > trip q
my_cs = color.ColorString(
[color.Epsilon(-1000, 2, 3),
color.T(1, 4, -1000)])
goal_cs = color.ColorString(
[color.T(4, 2001), color.Epsilon(2, 3, 1001)])
goal_cs.coeff = fractions.Fraction(1, 2)
self.assertEqual(
color_amp.ColorBasis.get_color_flow_string(my_cs,
[(8, 1, 1001, 2001)]),
goal_cs)
# g q > six q~
my_cs = color.ColorString(
[color.K6(3, -1000, 4),
color.T(1, -1000, 2)])
goal_cs = color.ColorString(
[color.T(1001, 2),
color.T(1003, 4),
color.T(3003, 2001)])
goal_cs.coeff = fractions.Fraction(1, 4)
self.assertEqual(
color_amp.ColorBasis.get_color_flow_string(my_cs,
[(8, 1, 1001, 2001),
(6, 3, 1003, 3003)]),
goal_cs)
# g q~ > trip > q~ q q~
my_cs = color.ColorString([
color.Epsilon(-1000, 2, 4),
color.EpsilonBar(-1001, 3, 5),
color.T(1, -1001, -1000)
])
goal_cs = color.ColorString(
[color.Epsilon(2, 4, 1001),
color.EpsilonBar(3, 5, 2001)])
goal_cs.coeff = fractions.Fraction(1, 2)
self.assertEqual(
color_amp.ColorBasis.get_color_flow_string(my_cs,
[(8, 1, 1001, 2001)]),
goal_cs)
class ColorAmpTest(unittest.TestCase):
"""Test class for the color_amp module"""
mypartlist = base_objects.ParticleList()
myinterlist = base_objects.InteractionList()
mymodel = base_objects.Model()
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)
# A photon
self.mypartlist.append(
base_objects.Particle({
'name': 'a',
'antiname': 'a',
'spin': 3,
'color': 1,
'mass': 'zero',
'width': 'zero',
'texname': '\gamma',
'antitexname': '\gamma',
'line': 'wavy',
'charge': 0.,
'pdg_code': 22,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
# A Higgs
self.mypartlist.append(
base_objects.Particle({
'name': 'h',
'antiname': 'h',
'spin': 1,
'color': 1,
'mass': 'mh',
'width': 'wh',
'texname': 'h',
'antitexname': 'h',
'line': 'dashed',
'charge': 0.,
'pdg_code': 25,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
# An electron e- and its antiparticle
self.mypartlist.append(
base_objects.Particle({
'name': 'e-',
'antiname': 'e+',
'spin': 2,
'color': 1,
'mass': 'zero',
'width': 'zero',
'texname': 'e^-',
'antitexname': 'e^+',
'line': 'straight',
'charge': 1,
'pdg_code': 11,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
antie = copy.copy(self.mypartlist[5])
antie.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}}))
# Photon coupling to up
self.myinterlist.append(base_objects.Interaction({
'id': 5,
'particles': base_objects.ParticleList(\
[self.mypartlist[1], \
antiu, \
self.mypartlist[3]]),
'color': [color.ColorString([color.T(0, 1)])],
'lorentz':['L1'],
'couplings':{(0, 0):'GQED'},
'orders':{'QED':1}}))
# Photon coupling to down
self.myinterlist.append(base_objects.Interaction({
'id': 6,
'particles': base_objects.ParticleList(\
[self.mypartlist[2], \
antid, \
self.mypartlist[3]]),
'color': [color.ColorString([color.T(0, 1)])],
'lorentz':['L1'],
'couplings':{(0, 0):'GQED'},
'orders':{'QED':1}}))
# Photon coupling to electrons
self.myinterlist.append(base_objects.Interaction({
'id': 7,
'particles': base_objects.ParticleList(\
[self.mypartlist[5], \
antie, \
self.mypartlist[3]]),
'color': [color.ColorString([color.T(0, 1)])],
'lorentz':['L1'],
'couplings':{(0, 0):'GQED'},
'orders':{'QED':1}}))
self.mymodel.set('particles', self.mypartlist)
self.mymodel.set('interactions', self.myinterlist)
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_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 test_color_basis_uux_aggg(self):
"""Test the color basis building for uu~ > aggg (3! elements)"""
myleglist = base_objects.LegList()
myleglist.append(base_objects.Leg({'id': -2, 'state': False}))
myleglist.append(base_objects.Leg({'id': 2, 'state': False}))
myleglist.append(base_objects.Leg({'id': 22, 'state': True}))
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()
new_col_basis = color_amp.ColorBasis(myamplitude)
self.assertEqual(len(new_col_basis), 6)
# Test the color flow decomposition
self.assertEqual(
new_col_basis.color_flow_decomposition(
{
1: 3,
2: -3,
3: 1,
4: 8,
5: 8,
6: -8
}, 2), [{
1: [0, 501],
2: [504, 0],
3: [0, 0],
4: [502, 501],
5: [503, 502],
6: [504, 503]
}, {
1: [0, 501],
2: [503, 0],
3: [0, 0],
4: [502, 501],
5: [503, 504],
6: [504, 502]
}, {
1: [0, 501],
2: [504, 0],
3: [0, 0],
4: [502, 503],
5: [503, 501],
6: [504, 502]
}, {
1: [0, 501],
2: [502, 0],
3: [0, 0],
4: [502, 504],
5: [503, 501],
6: [504, 503]
}, {
1: [0, 501],
2: [503, 0],
3: [0, 0],
4: [502, 504],
5: [503, 502],
6: [504, 501]
}, {
1: [0, 501],
2: [502, 0],
3: [0, 0],
4: [502, 503],
5: [503, 504],
6: [504, 501]
}])
def test_color_flow_string(self):
"""Test the color flow decomposition of various color strings"""
# qq~>qq~
my_cs = color.ColorString([color.T(-1000, 1, 2), color.T(-1000, 3, 4)])
goal_cs = color.ColorString([color.T(1, 4), color.T(3, 2)])
goal_cs.coeff = fractions.Fraction(1, 2)
self.assertEqual(color_amp.ColorBasis.get_color_flow_string(my_cs, []),
goal_cs)
# qq~>qq~g
my_cs = color.ColorString(
[color.T(-1000, 1, 2),
color.T(-1000, 3, 4),
color.T(5, 4, 6)])
goal_cs = color.ColorString(
[color.T(1, 2005),
color.T(3, 2), color.T(1005, 6)])
goal_cs.coeff = fractions.Fraction(1, 4)
self.assertEqual(
color_amp.ColorBasis.get_color_flow_string(my_cs,
[(8, 5, 1005, 2005)]),
goal_cs)
# gg>gg
my_cs = color.ColorString(
[color.Tr(-1000, 1, 2),
color.Tr(-1000, 3, 4)])
goal_cs = color.ColorString([
color.T(1001, 2002),
color.T(1002, 2003),
color.T(1003, 2004),
color.T(1004, 2001)
])
goal_cs.coeff = fractions.Fraction(1, 32)
self.assertEqual(
color_amp.ColorBasis.get_color_flow_string(my_cs,
[(8, 1, 1001, 2001),
(8, 2, 1002, 2002),
(8, 3, 1003, 2003),
(8, 4, 1004, 2004)]),
goal_cs)
def test_color_flow_string_epsilon(self):
"""Test the color flow decomposition of strings including Epsilon
and color sextets"""
# g q > trip q
my_cs = color.ColorString(
[color.Epsilon(-1000, 2, 3),
color.T(1, 4, -1000)])
goal_cs = color.ColorString(
[color.T(4, 2001), color.Epsilon(2, 3, 1001)])
goal_cs.coeff = fractions.Fraction(1, 2)
self.assertEqual(
color_amp.ColorBasis.get_color_flow_string(my_cs,
[(8, 1, 1001, 2001)]),
goal_cs)
# g q > six q~
my_cs = color.ColorString(
[color.K6(3, -1000, 4),
color.T(1, -1000, 2)])
goal_cs = color.ColorString(
[color.T(1001, 2),
color.T(1003, 4),
color.T(3003, 2001)])
goal_cs.coeff = fractions.Fraction(1, 4)
self.assertEqual(
color_amp.ColorBasis.get_color_flow_string(my_cs,
[(8, 1, 1001, 2001),
(6, 3, 1003, 3003)]),
goal_cs)
# g q~ > trip > q~ q q~
my_cs = color.ColorString([
color.Epsilon(-1000, 2, 4),
color.EpsilonBar(-1001, 3, 5),
color.T(1, -1001, -1000)
])
goal_cs = color.ColorString(
[color.Epsilon(2, 4, 1001),
color.EpsilonBar(3, 5, 2001)])
goal_cs.coeff = fractions.Fraction(1, 2)
self.assertEqual(
color_amp.ColorBasis.get_color_flow_string(my_cs,
[(8, 1, 1001, 2001)]),
goal_cs)
def perform_color_connections_test(self, combinations):
""" Handy wrapping function to test selected cases for the color correlated matrices."""
def compare_result(color_matrices, color_connections, reference):
important_info_CM = [(c[0], dict(c[1][1].col_matrix_fixed_Nc))
for c in color_matrices
if c[1][1].col_matrix_fixed_Nc is not None]
important_info_CC = {
k: [(i, cc['tuple_representation']) for i, cc in enumerate(v)]
for k, v in color_connections.items()
}
#pprint(important_info_CM)
#pprint(important_info_CC)
self.assertListEqual(important_info_CM,
reference['color_matrices'])
self.assertDictEqual(important_info_CC,
reference['color_connections'])
for n_gluons, initial_states, max_order, reference in combinations:
myleglist = base_objects.LegList()
myleglist.append(
base_objects.Leg({
'id': initial_states[0],
'state': False
}))
myleglist.append(
base_objects.Leg({
'id': initial_states[1],
'state': False
}))
myleglist.append(base_objects.Leg({'id': 1, 'state': True}))
myleglist.append(base_objects.Leg({'id': -1, 'state': True}))
myleglist.extend([base_objects.Leg({
'id': 21,
'state': True
})] * (n_gluons))
myprocess = base_objects.Process({
'legs': myleglist,
'model': self.mymodel
})
myamplitude = diagram_generation.Amplitude()
myamplitude.set('process', myprocess)
myamplitude.generate_diagrams()
col_basis = color_amp.ColorBasis(myamplitude)
col_matrix = color_amp.ColorMatrix(col_basis, Nc=3)
all_color_matrices, color_connections = col_matrix.build_color_correlated_matrices(
myleglist,
self.mymodel,
order=max_order,
Nc=3,
Nc_power_min=None,
Nc_power_max=None)
# Now aggregate all color_connections in a single list:
all_color_connections = []
for o in range(max_order.count('N') + 1):
all_color_connections.extend(color_connections['N' * o + 'LO'])
sorted_color_matrices = sorted(all_color_matrices.items(),
key=lambda el: el[0])
compare_result(sorted_color_matrices, color_connections, reference)
if False:
pprint([(
'(%d,%d) -> [ %s | %s ]' %
(k[0], k[1],
str(all_color_connections[k[0]]['tuple_representation']),
str(all_color_connections[k[1]]['tuple_representation'])),
(v[0], v[1].col_matrix_fixed_Nc))
for k, v in sorted_color_matrices])
if False:
print(
"\nA total of %d correlator matrices have been computed (among which %d are zero)"
% (len(sorted_color_matrices),
len([
_ for _ in sorted_color_matrices
if _[1][1].col_matrix_fixed_Nc is None
])))
def test_color_correlators_computation_slow(self):
""" Test the functions in ColorMatrix related to the generation of color-correlated
Matrix elements, for cases that are fast to evaluate."""
from color_connections_reference_results import \
epem_ddxgg_NNLO_res, \
ddx_ddx_NNLO_res, \
epem_ddx_NNNLO_res
# The tests that are commented are not because they're not working but just
# because they are too slow for unit tests
combinations = [
## NNLO
#######
## e+ e- > d d~ g g @NNLO
(2, [11, -11], 'NNLO', epem_ddxgg_NNLO_res),
## d d~ > d d~ @NNLO
(0, [1, -1], 'NNLO', ddx_ddx_NNLO_res),
## NNNLO
#######
## e+ e- > d d~ @NNNLO
(0, [11, -11], 'NNNLO', epem_ddx_NNNLO_res),
## g g > d d~ @NNNLO
# These results are too large to be stored in the hardcoded reference
# results and we skip them. (also too slow for unit tests.
# But it's working in principle.
#(0,[21,21],'NNNLO',gg_ddx_NNNLO_res),
## d d~ > d d~ @NNNLO
#(0,[1,-1],'NNNLO',ddx_ddx_NNNLO_res),
]
self.perform_color_connections_test(combinations)
def test_color_correlators_computation_fast(self):
""" Test the functions in ColorMatrix related to the generation of color-correlated
Matrix elements, for cases that are slow to evaluate."""
from color_connections_reference_results import \
epem_ddx_NLO_res, \
epem_ddx_NNLO_res, \
epem_ddxg_NLO_res, \
epem_ddxg_NNLO_res, \
epem_ddxgg_NLO_res, \
gg_ddx_NLO_res, \
gg_ddxg_NLO_res, \
ddx_ddx_NLO_res
# The tests that are commented are not because they're not working but just
# because they are too slow for unit tests
combinations = [
## NLO
######
## e+ e- > d d~ @NLO
(0, [11, -11], 'NLO', epem_ddx_NLO_res),
## e+ e- > d d~ g @NLO
(1, [11, -11], 'NLO', epem_ddxg_NLO_res),
## e+ e- > d d~ g g @NLO
(2, [11, -11], 'NLO', epem_ddxgg_NLO_res),
## g g > d d~ @NLO
(0, [21, 21], 'NLO', gg_ddx_NLO_res),
## g g > d d~ g @NLO
(1, [21, 21], 'NLO', gg_ddxg_NLO_res),
## d d~ > d d~ @NLO
(0, [1, -1], 'NLO', ddx_ddx_NLO_res),
## NNLO
#######
## e+ e- > d d~ @NNLO
(0, [11, -11], 'NNLO', epem_ddx_NNLO_res),
## e+ e- > d d~ g @NNLO
(1, [11, -11], 'NNLO', epem_ddxg_NNLO_res),
]
self.perform_color_connections_test(combinations)
}))
# u u~ y
interactions.append(base_objects.Interaction({
'id': 5,
'particles': base_objects.ParticleList([
up, antiup, photon
]),
'color': [color.ColorString([color.T(0, 1)])],
'lorentz': ['L1'],
'couplings': {(0, 0): 'GQED'},
'orders': {'QED': 1}
}))
# Model
#=========================================================================================
model = base_objects.Model({
'particles': particles,
'name': "simple_QCD",
'interactions': interactions
})
# Masses
#=========================================================================================
masses = {
'zero': 0.,
'mh': 1.
}
if not absolute:
raise InvalidCmd, "%s directory is not a valid v4 model" % \
(model_path)
else:
return import_model(model_path_old, mgme_dir, False)
# use pickle files if defined
if files.is_uptodate(os.path.join(model_path, 'model.pkl'), files_list):
model = save_load_object.load_from_file( \
os.path.join(model_path, 'model.pkl'))
if model.has_key('version_tag') and model.get(
'version_tag') == os.path.realpath(model_path) + str(
misc.get_pkg_info()):
return model, model_path
model = base_objects.Model()
model.set('particles',files.read_from_file( \
os.path.join(model_path, 'particles.dat'),
read_particles_v4))
model.set('interactions',files.read_from_file( \
os.path.join(model_path, 'interactions.dat'),
read_interactions_v4,
model['particles']))
model.set('name', os.path.split(model_path)[-1])
# save in a pickle files to fasten future usage
if ReadWrite:
try:
save_load_object.save_to_file(
def test_ungrouping_lepton(self):
"""check that the routines which ungroup the process for the muon/electron processes
works as expected"""
# Setup A simple model
mypartlist = base_objects.ParticleList()
myinterlist = base_objects.InteractionList()
# A quark U and its antiparticle
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
}))
u = mypartlist[-1]
antiu = copy.copy(u)
antiu.set('is_part', False)
# A quark D and its antiparticle
mypartlist.append(
base_objects.Particle({
'name': 'd',
'antiname': 'd~',
'spin': 2,
'color': 3,
'mass': 'zero',
'width': 'zero',
'texname': 'd',
'antitexname': '\bar d',
'line': 'straight',
'charge': -1. / 3.,
'pdg_code': 1,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
d = mypartlist[-1]
antid = copy.copy(d)
antid.set('is_part', False)
# A quark C and its antiparticle
mypartlist.append(
base_objects.Particle({
'name': 'c',
'antiname': 'c~',
'spin': 2,
'color': 3,
'mass': 'zero',
'width': 'zero',
'texname': 'u',
'antitexname': '\bar u',
'line': 'straight',
'charge': 2. / 3.,
'pdg_code': 4,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
c = mypartlist[-1]
antic = copy.copy(c)
antic.set('is_part', False)
# electron/positront
mypartlist.append(
base_objects.Particle({
'name': 'e-',
'antiname': 'e+',
'spin': 2,
'color': 1,
'mass': 'zero',
'width': 'zero',
'texname': 'u',
'antitexname': '\bar u',
'line': 'straight',
'charge': 1,
'pdg_code': 11,
'propagating': True,
'is_part': True,
'self_antipart': False
}))
e = mypartlist[-1]
antie = copy.copy(e)
mu = copy.copy(e)
antie.set('is_part', False)
mu.set('name', 'mu-')
mu.set('antiname', 'mu+')
mu.set('pdg_code', 13)
mypartlist.append(mu)
antimu = copy.copy(mu)
antimu.set('is_part', False)
# A Z
mypartlist.append(
base_objects.Particle({
'name': 'z',
'antiname': 'z',
'spin': 3,
'color': 1,
'mass': 'MZ',
'width': 'WZ',
'texname': 'Z',
'antitexname': 'Z',
'line': 'wavy',
'charge': 0.,
'pdg_code': 23,
'propagating': True,
'is_part': True,
'self_antipart': True
}))
z = mypartlist[-1]
# Coupling of Z to quarks
myinterlist.append(base_objects.Interaction({
'id': 1,
'particles': base_objects.ParticleList(\
[antiu, \
u, \
z]),
'color': [color.ColorString([color.T(1,0)])],
'lorentz':['FFV1', 'FFV2'],
'couplings':{(0, 0):'GUZ1', (0, 1):'GUZ2'},
'orders':{'QED':1}}))
myinterlist.append(base_objects.Interaction({
'id': 2,
'particles': base_objects.ParticleList(\
[antid, \
d, \
z]),
'color': [color.ColorString([color.T(1,0)])],
'lorentz':['FFV1', 'FFV2'],
'couplings':{(0, 0):'GDZ1', (0, 1):'GDZ2'},
'orders':{'QED':1}}))
myinterlist.append(base_objects.Interaction({
'id': 3,
'particles': base_objects.ParticleList(\
[antic, \
c, \
z]),
'color': [color.ColorString([color.T(1,0)])],
'lorentz':['FFV1', 'FFV2'],
'couplings':{(0, 0):'GUZ1', (0, 1):'GUZ2'},
'orders':{'QED':1}}))
# Coupling of Z to leptons
myinterlist.append(base_objects.Interaction({
'id': 4,
'particles': base_objects.ParticleList(\
[antie, \
e, \
z]),
'color': [color.ColorString()],
'lorentz':['FFV1', 'FFV2'],
'couplings':{(0, 0):'GLZ1', (0, 1):'GLZ2'},
'orders':{'QED':1}}))
# Coupling of Z to leptons
myinterlist.append(base_objects.Interaction({
'id': 5,
'particles': base_objects.ParticleList(\
[antimu, \
mu, \
z]),
'color': [color.ColorString()],
'lorentz':['FFV1', 'FFV2'],
'couplings':{(0, 0):'GLZ1', (0, 1):'GLZ2'},
'orders':{'QED':1}}))
mymodel = base_objects.Model()
mymodel.set('particles', mypartlist)
mymodel.set('interactions', myinterlist)
mymodel.set('name', 'sm')
procs = [[1, -1, 23], [2, -2, 23], [4, -4, 23]]
decays = [[23, 11, -11], [23, 13, -13]]
coreamplitudes = diagram_generation.AmplitudeList()
decayamplitudes = diagram_generation.AmplitudeList()
decayprocs = base_objects.ProcessList()
#Building the basic objects
for proc in procs:
# Define the multiprocess
my_leglist = base_objects.LegList([\
base_objects.Leg({'id': id, 'state': True}) for id in proc])
my_leglist[0].set('state', False)
my_leglist[1].set('state', False)
my_process = base_objects.Process({
'legs': my_leglist,
'model': mymodel
})
my_amplitude = diagram_generation.Amplitude(my_process)
my_amplitude.set('has_mirror_process', True)
coreamplitudes.append(my_amplitude)
for proc in decays:
# Define the multiprocess
my_leglist = base_objects.LegList([\
base_objects.Leg({'id': id, 'state': True}) for id in proc])
my_leglist[0].set('state', False)
my_process = base_objects.Process({
'legs': my_leglist,
'model': mymodel,
'is_decay_chain': True
})
my_amplitude = diagram_generation.Amplitude(my_process)
decayamplitudes.append(my_amplitude)
decayprocs.append(my_process)
decays = diagram_generation.DecayChainAmplitudeList([\
diagram_generation.DecayChainAmplitude({\
'amplitudes': decayamplitudes})])
decay_chains = diagram_generation.DecayChainAmplitude({\
'amplitudes': coreamplitudes,
'decay_chains': decays})
dc_subproc_group = group_subprocs.DecayChainSubProcessGroup.\
group_amplitudes(\
diagram_generation.DecayChainAmplitudeList([decay_chains]))
subproc_groups = \
dc_subproc_group.generate_helas_decay_chain_subproc_groups()
######################
## Make the test!! ##
######################
self.assertEqual(len(subproc_groups), 1)
subproc_groups = subproc_groups.split_lepton_grouping()
self.assertEqual(len(subproc_groups), 2)
# check that indeed
for group in subproc_groups:
self.assertEqual(len(group['matrix_elements']), 2)
has_muon = any(
abs(l['id']) == 13 for l in group['matrix_elements'][0]
['processes'][0]['decay_chains'][0]['legs'])
for me in group['matrix_elements']:
if abs(me['processes'][0]['legs'][0]['id']) == 1:
self.assertEqual(len(me['processes']), 1)
else:
self.assertEqual(len(me['processes']), 2)
for proc in me['processes']:
for dec in proc['decay_chains']:
if has_muon:
self.assertFalse(
any(abs(l['id']) == 11 for l in dec['legs']))
else:
self.assertFalse(
any(abs(l['id']) == 13 for l in dec['legs']))
self.assertNotEqual(group['name'], 'qq_z_z_ll')
if has_muon:
self.assertEqual(group['name'], 'qq_z_z_mummup')
else:
self.assertEqual(group['name'], 'qq_z_z_emep')
group['name']
