diff --git a/Models/Feynrules/python/ufo2peg/general_lorentz.py b/Models/Feynrules/python/ufo2peg/general_lorentz.py
--- a/Models/Feynrules/python/ufo2peg/general_lorentz.py
+++ b/Models/Feynrules/python/ufo2peg/general_lorentz.py
@@ -1,2588 +1,2807 @@
import copy
from .helpers import SkipThisVertex,def_from_model
from .converter import py2cpp
import string,re
from string import Template
import sympy
from sympy import Matrix,Symbol
epsValue=[[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],
[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]],
[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],
[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]],
[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],
[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]],
[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],
[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]]]
epsValue[0][1][2][3] = -1.
epsValue[0][1][3][2] = 1.
epsValue[0][2][1][3] = 1.
epsValue[0][2][3][1] = -1.
epsValue[0][3][1][2] = -1.
epsValue[0][3][2][1] = 1.
epsValue[1][0][2][3] = 1.
epsValue[1][0][3][2] = -1.
epsValue[1][2][0][3] = -1.
epsValue[1][2][3][0] = 1.
epsValue[1][3][0][2] = 1.
epsValue[1][3][2][0] = -1.
epsValue[2][0][1][3] = -1.
epsValue[2][0][3][1] = 1.
epsValue[2][1][0][3] = 1.
epsValue[2][1][3][0] = -1.
epsValue[2][3][0][1] = -1.
epsValue[2][3][1][0] = 1.
epsValue[3][0][1][2] = 1.
epsValue[3][0][2][1] = -1.
epsValue[3][1][0][2] = -1.
epsValue[3][1][2][0] = 1.
epsValue[3][2][0][1] = 1.
epsValue[3][2][1][0] = -1.
+# self contracted tensor propagator
+tPropA=[[],[],[],[]]
+tPropA[0].append(Template("-2. / 3. * (M${iloc}2 + 2 * P${iloc}t ** 2) * (M${iloc}2 -p2)*OM${iloc}**2"))
+tPropA[0].append(Template("-4. / 3. * P${iloc}t * P${iloc}x * (M${iloc}2 -p2)*OM${iloc}**2"))
+tPropA[0].append(Template("-4. / 3. * P${iloc}t * P${iloc}y * (M${iloc}2 -p2)*OM${iloc}**2"))
+tPropA[0].append(Template("-4. / 3. * P${iloc}t * P${iloc}z * (M${iloc}2 -p2)*OM${iloc}**2"))
+tPropA[1].append(Template("-4. / 3. * P${iloc}t * P${iloc}x * (M${iloc}2 -p2)*OM${iloc}**2"))
+tPropA[1].append(Template(" 2. / 3. * (M${iloc}2 - 2 * P${iloc}x ** 2) * (M${iloc}2 -p2)*OM${iloc}**2"))
+tPropA[1].append(Template("-4. / 3. * P${iloc}x * P${iloc}y * (M${iloc}2 -p2)*OM${iloc}**2"))
+tPropA[1].append(Template("-4. / 3. * P${iloc}x * P${iloc}z * (M${iloc}2 -p2)*OM${iloc}**2"))
+tPropA[2].append(Template("-4. / 3. * P${iloc}t * P${iloc}y * (M${iloc}2 -p2)*OM${iloc}**2"))
+tPropA[2].append(Template("-4. / 3. * P${iloc}x * P${iloc}y * (M${iloc}2 -p2)*OM${iloc}**2"))
+tPropA[2].append(Template(" 2. / 3. * (M${iloc}2 - 2 * P${iloc}y ** 2) * (M${iloc}2 -p2)*OM${iloc}**2"))
+tPropA[2].append(Template("-4. / 3. * P${iloc}y * P${iloc}z * (M${iloc}2 -p2)*OM${iloc}**2"))
+tPropA[3].append(Template("-4. / 3. * P${iloc}t * P${iloc}z * (M${iloc}2 -p2)*OM${iloc}**2"))
+tPropA[3].append(Template("-4. / 3. * P${iloc}x * P${iloc}z * (M${iloc}2 -p2)*OM${iloc}**2"))
+tPropA[3].append(Template("-4. / 3. * P${iloc}y * P${iloc}z * (M${iloc}2 -p2)*OM${iloc}**2"))
+tPropA[3].append(Template(" 2. / 3. * (M${iloc}2 - 2 * P${iloc}z ** 2) * (M${iloc}2 -p2)*OM${iloc}**2"))
+
+# tensor propagator 1 index contracted
+tPropB=[[[],[],[],[]],[[],[],[],[]],[[],[],[],[]],[[],[],[],[]]]
+tPropB[0][0].append(Template("4. / 3. * (${V}t - ${dot}*OM${iloc} * P${iloc}t) * (1. - OM${iloc} * P${iloc}t ** 2)"))
+tPropB[0][0].append(Template("-2 * (${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}t * P${iloc}x - 2. / 3. * (1. - OM${iloc} * P${iloc}t ** 2) * (${V}x - ${dot}*OM${iloc} * P${iloc}x)"))
+tPropB[0][0].append(Template(" -2 * (${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}t * P${iloc}y - 2. / 3. * (1. - OM${iloc} * P${iloc}t ** 2) * (${V}y - ${dot}*OM${iloc} * P${iloc}y)"))
+tPropB[0][0].append(Template(" -2 * (${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}t * P${iloc}z - 2. / 3. * (1. - OM${iloc} * P${iloc}t ** 2) * (${V}z - ${dot}*OM${iloc} * P${iloc}z)"))
+tPropB[0][1].append(Template(" -(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}t * P${iloc}x / 3. + (1. - OM${iloc} * P${iloc}t ** 2) * (${V}x - ${dot}*OM${iloc} * P${iloc}x)"))
+tPropB[0][1].append(Template(" (${V}t - ${dot}*OM${iloc} * P${iloc}t) * (-1. - OM${iloc} * P${iloc}x ** 2) - OM${iloc} * P${iloc}t * P${iloc}x * (${V}x - ${dot}*OM${iloc} * P${iloc}x) / 3."))
+tPropB[0][1].append(Template("-(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}x * P${iloc}y - OM${iloc} * P${iloc}t * P${iloc}y * (${V}x - ${dot}*OM${iloc} * P${iloc}x) + 2. / 3.*OM${iloc} * P${iloc}t * P${iloc}x * (${V}y - ${dot}*OM${iloc} * P${iloc}y)"))
+tPropB[0][1].append(Template("-(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}x * P${iloc}z - OM${iloc} * P${iloc}t * P${iloc}z * (${V}x - ${dot}*OM${iloc} * P${iloc}x) + 2. / 3.*OM${iloc} * P${iloc}t * P${iloc}x * (${V}z - ${dot}*OM${iloc} * P${iloc}z)"))
+tPropB[0][2].append(Template(" -(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}t * P${iloc}y / 3. + (1. - OM${iloc} * P${iloc}t ** 2) * (${V}y - ${dot}*OM${iloc} * P${iloc}y)"))
+tPropB[0][2].append(Template("-(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}x * P${iloc}y - OM${iloc} * P${iloc}t * P${iloc}x * (${V}y - ${dot}*OM${iloc} * P${iloc}y) + 2. / 3.*OM${iloc} * P${iloc}t * P${iloc}y * (${V}x - ${dot}*OM${iloc} * P${iloc}x)"))
+tPropB[0][2].append(Template(" (${V}t - ${dot}*OM${iloc} * P${iloc}t) * (-1. - OM${iloc} * P${iloc}y ** 2) - OM${iloc} * P${iloc}t * P${iloc}y * (${V}y - ${dot}*OM${iloc} * P${iloc}y) / 3."))
+tPropB[0][2].append(Template("-(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}y * P${iloc}z - OM${iloc} * P${iloc}t * P${iloc}z * (${V}y - ${dot}*OM${iloc} * P${iloc}y) + 2. / 3.*OM${iloc} * P${iloc}t * P${iloc}y * (${V}z - ${dot}*OM${iloc} * P${iloc}z)"))
+tPropB[0][3].append(Template(" -(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}t * P${iloc}z / 3. + (1. - OM${iloc} * P${iloc}t ** 2) * (${V}z - ${dot}*OM${iloc} * P${iloc}z)"))
+tPropB[0][3].append(Template("-(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}x * P${iloc}z - OM${iloc} * P${iloc}t * P${iloc}x * (${V}z - ${dot}*OM${iloc} * P${iloc}z) + 2. / 3.*OM${iloc} * P${iloc}t * P${iloc}z * (${V}x - ${dot}*OM${iloc} * P${iloc}x)"))
+tPropB[0][3].append(Template(" -(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}y * P${iloc}z - OM${iloc} * P${iloc}t * P${iloc}y * (${V}z - ${dot}*OM${iloc} * P${iloc}z) + 2. / 3.*OM${iloc} * P${iloc}t * P${iloc}z * (${V}y - ${dot}*OM${iloc} * P${iloc}y)"))
+tPropB[0][3].append(Template("(${V}t - ${dot}*OM${iloc} * P${iloc}t) * (-1. - OM${iloc} * P${iloc}z ** 2) - OM${iloc} * P${iloc}t * P${iloc}z * (${V}z - ${dot}*OM${iloc} * P${iloc}z) / 3."))
+
+tPropB[1][0].append(Template("-(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}t * P${iloc}x / 3. + (1 - OM${iloc} * P${iloc}t ** 2) * (${V}x - ${dot}*OM${iloc} * P${iloc}x)"))
+tPropB[1][0].append(Template(" (${V}t - ${dot}*OM${iloc} * P${iloc}t) * (-1 - OM${iloc} * P${iloc}x ** 2) - OM${iloc} * P${iloc}t * P${iloc}x * (${V}x - ${dot}*OM${iloc} * P${iloc}x) / 3."))
+tPropB[1][0].append(Template(" -(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}x * P${iloc}y - OM${iloc} * P${iloc}t * P${iloc}y * (${V}x - ${dot}*OM${iloc} * P${iloc}x) + 2. / 3.*OM${iloc} * P${iloc}t * P${iloc}x * (${V}y - ${dot}*OM${iloc} * P${iloc}y)"))
+tPropB[1][0].append(Template(" -(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}x * P${iloc}z - OM${iloc} * P${iloc}t * P${iloc}z * (${V}x - ${dot}*OM${iloc} * P${iloc}x) + 2. / 3.*OM${iloc} * P${iloc}t * P${iloc}x * (${V}z - ${dot}*OM${iloc} * P${iloc}z)"))
+tPropB[1][1].append(Template(" -2*OM${iloc} * P${iloc}t * P${iloc}x * (${V}x - ${dot}*OM${iloc} * P${iloc}x) - 2. / 3. * (${V}t - ${dot}*OM${iloc} * P${iloc}t) * (-1 - OM${iloc} * P${iloc}x ** 2)"))
+tPropB[1][1].append(Template(" 4. / 3. * (${V}x - ${dot}*OM${iloc} * P${iloc}x) * (-1 - OM${iloc} * P${iloc}x ** 2)"))
+tPropB[1][1].append(Template(" -2 * (${V}x - ${dot}*OM${iloc} * P${iloc}x)*OM${iloc} * P${iloc}x * P${iloc}y - 2. / 3. * (-1 - OM${iloc} * P${iloc}x ** 2) * (${V}y - ${dot}*OM${iloc} * P${iloc}y)"))
+tPropB[1][1].append(Template(" -2 * (${V}x - ${dot}*OM${iloc} * P${iloc}x)*OM${iloc} * P${iloc}x * P${iloc}z - 2. / 3. * (-1 - OM${iloc} * P${iloc}x ** 2) * (${V}z - ${dot}*OM${iloc} * P${iloc}z)"))
+tPropB[1][2].append(Template(" -OM${iloc} * P${iloc}t * P${iloc}y * (${V}x - ${dot}*OM${iloc} * P${iloc}x) - OM${iloc} * P${iloc}t * P${iloc}x * (${V}y - ${dot}*OM${iloc} * P${iloc}y) + 2. / 3. * (${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}x * P${iloc}y"))
+tPropB[1][2].append(Template(" -(${V}x - ${dot}*OM${iloc} * P${iloc}x)*OM${iloc} * P${iloc}x * P${iloc}y / 3. + (-1 - OM${iloc} * P${iloc}x ** 2) * (${V}y - ${dot}*OM${iloc} * P${iloc}y)"))
+tPropB[1][2].append(Template(" (${V}x - ${dot}*OM${iloc} * P${iloc}x) * (-1 - OM${iloc} * P${iloc}y ** 2) - OM${iloc} * P${iloc}x * P${iloc}y * (${V}y - ${dot}*OM${iloc} * P${iloc}y) / 3."))
+tPropB[1][2].append(Template("-(${V}x - ${dot}*OM${iloc} * P${iloc}x)*OM${iloc} * P${iloc}y * P${iloc}z - OM${iloc} * P${iloc}x * P${iloc}z * (${V}y - ${dot}*OM${iloc} * P${iloc}y) + 2. / 3.*OM${iloc} * P${iloc}x * P${iloc}y * (${V}z - ${dot}*OM${iloc} * P${iloc}z)"))
+tPropB[1][3].append(Template("-OM${iloc} * P${iloc}t * P${iloc}z * (${V}x - ${dot}*OM${iloc} * P${iloc}x) - OM${iloc} * P${iloc}t * P${iloc}x * (${V}z - ${dot}*OM${iloc} * P${iloc}z) + 2. / 3. * (${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}x * P${iloc}z"))
+tPropB[1][3].append(Template(" -(${V}x - ${dot}*OM${iloc} * P${iloc}x)*OM${iloc} * P${iloc}x * P${iloc}z / 3. + (-1 - OM${iloc} * P${iloc}x ** 2) * (${V}z - ${dot}*OM${iloc} * P${iloc}z)"))
+tPropB[1][3].append(Template(" -(${V}x - ${dot}*OM${iloc} * P${iloc}x)*OM${iloc} * P${iloc}y * P${iloc}z - OM${iloc} * P${iloc}x * P${iloc}y * (${V}z - ${dot}*OM${iloc} * P${iloc}z) + 2. / 3.*OM${iloc} * P${iloc}x * P${iloc}z * (${V}y - ${dot}*OM${iloc} * P${iloc}y)"))
+tPropB[1][3].append(Template("(${V}x - ${dot}*OM${iloc} * P${iloc}x) * (-1 - OM${iloc} * P${iloc}z ** 2) - OM${iloc} * P${iloc}x * P${iloc}z * (${V}z - ${dot}*OM${iloc} * P${iloc}z) / 3."))
+
+tPropB[2][0].append(Template(" -(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}t * P${iloc}y / 3. + (1 - OM${iloc} * P${iloc}t ** 2) * (${V}y - ${dot}*OM${iloc} * P${iloc}y)"))
+tPropB[2][0].append(Template(" -(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}x * P${iloc}y - OM${iloc} * P${iloc}t * P${iloc}x * (${V}y - ${dot}*OM${iloc} * P${iloc}y) + 2. / 3.*OM${iloc} * P${iloc}t * P${iloc}y * (${V}x - ${dot}*OM${iloc} * P${iloc}x)"))
+tPropB[2][0].append(Template(" (${V}t - ${dot}*OM${iloc} * P${iloc}t) * (-1 - OM${iloc} * P${iloc}y ** 2) - OM${iloc} * P${iloc}t * P${iloc}y * (${V}y - ${dot}*OM${iloc} * P${iloc}y) / 3."))
+tPropB[2][0].append(Template(" -(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}y * P${iloc}z - OM${iloc} * P${iloc}t * P${iloc}z * (${V}y - ${dot}*OM${iloc} * P${iloc}y) + 2. / 3.*OM${iloc} * P${iloc}t * P${iloc}y * (${V}z - ${dot}*OM${iloc} * P${iloc}z)"))
+tPropB[2][1].append(Template("-OM${iloc} * P${iloc}t * P${iloc}y * (${V}x - ${dot}*OM${iloc} * P${iloc}x) - OM${iloc} * P${iloc}t * P${iloc}x * (${V}y - ${dot}*OM${iloc} * P${iloc}y) + 2. / 3. * (${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}x * P${iloc}y"))
+tPropB[2][1].append(Template("-(${V}x - ${dot}*OM${iloc} * P${iloc}x)*OM${iloc} * P${iloc}x * P${iloc}y / 3. + (-1 - OM${iloc} * P${iloc}x ** 2) * (${V}y - ${dot}*OM${iloc} * P${iloc}y)"))
+tPropB[2][1].append(Template(" (${V}x - ${dot}*OM${iloc} * P${iloc}x) * (-1 - OM${iloc} * P${iloc}y ** 2) - OM${iloc} * P${iloc}x * P${iloc}y * (${V}y - ${dot}*OM${iloc} * P${iloc}y) / 3."))
+tPropB[2][1].append(Template("-(${V}x - ${dot}*OM${iloc} * P${iloc}x)*OM${iloc} * P${iloc}y * P${iloc}z - OM${iloc} * P${iloc}x * P${iloc}z * (${V}y - ${dot}*OM${iloc} * P${iloc}y) + 2. / 3.*OM${iloc} * P${iloc}x * P${iloc}y * (${V}z - ${dot}*OM${iloc} * P${iloc}z)"))
+tPropB[2][2].append(Template(" -2*OM${iloc} * P${iloc}t * P${iloc}y * (${V}y - ${dot}*OM${iloc} * P${iloc}y) - 2. / 3. * (${V}t - ${dot}*OM${iloc} * P${iloc}t) * (-1 - OM${iloc} * P${iloc}y ** 2)"))
+tPropB[2][2].append(Template(" -2*OM${iloc} * P${iloc}x * P${iloc}y * (${V}y - ${dot}*OM${iloc} * P${iloc}y) - 2. / 3. * (${V}x - ${dot}*OM${iloc} * P${iloc}x) * (-1 - OM${iloc} * P${iloc}y ** 2)"))
+tPropB[2][2].append(Template("4. / 3. * (${V}y - ${dot}*OM${iloc} * P${iloc}y) * (-1 - OM${iloc} * P${iloc}y ** 2)"))
+tPropB[2][2].append(Template(" -2 * (${V}y - ${dot}*OM${iloc} * P${iloc}y)*OM${iloc} * P${iloc}y * P${iloc}z - 2. / 3. * (-1 - OM${iloc} * P${iloc}y ** 2) * (${V}z - ${dot}*OM${iloc} * P${iloc}z)"))
+tPropB[2][3].append(Template(" -OM${iloc} * P${iloc}t * P${iloc}z * (${V}y - ${dot}*OM${iloc} * P${iloc}y) - OM${iloc} * P${iloc}t * P${iloc}y * (${V}z - ${dot}*OM${iloc} * P${iloc}z) + 2. / 3. * (${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}y * P${iloc}z"))
+tPropB[2][3].append(Template(" -OM${iloc} * P${iloc}x * P${iloc}z * (${V}y - ${dot}*OM${iloc} * P${iloc}y) - OM${iloc} * P${iloc}x * P${iloc}y * (${V}z - ${dot}*OM${iloc} * P${iloc}z) + 2. / 3. * (${V}x - ${dot}*OM${iloc} * P${iloc}x)*OM${iloc} * P${iloc}y * P${iloc}z"))
+tPropB[2][3].append(Template(" -(${V}y - ${dot}*OM${iloc} * P${iloc}y)*OM${iloc} * P${iloc}y * P${iloc}z / 3. + (-1 - OM${iloc} * P${iloc}y ** 2) * (${V}z - ${dot}*OM${iloc} * P${iloc}z)"))
+tPropB[2][3].append(Template(" (${V}y - ${dot}*OM${iloc} * P${iloc}y) * (-1 - OM${iloc} * P${iloc}z ** 2) - OM${iloc} * P${iloc}y * P${iloc}z * (${V}z - ${dot}*OM${iloc} * P${iloc}z) / 3."))
+
+tPropB[3][0].append(Template(" -(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}t * P${iloc}z / 3. + (1 - OM${iloc} * P${iloc}t ** 2) * (${V}z - ${dot}*OM${iloc} * P${iloc}z)"))
+tPropB[3][0].append(Template(" -(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}x * P${iloc}z - OM${iloc} * P${iloc}t * P${iloc}x * (${V}z - ${dot}*OM${iloc} * P${iloc}z) + 2. / 3.*OM${iloc} * P${iloc}t * P${iloc}z * (${V}x - ${dot}*OM${iloc} * P${iloc}x)"))
+tPropB[3][0].append(Template("-(${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}y * P${iloc}z - OM${iloc} * P${iloc}t * P${iloc}y * (${V}z - ${dot}*OM${iloc} * P${iloc}z) + 2. / 3.*OM${iloc} * P${iloc}t * P${iloc}z * (${V}y - ${dot}*OM${iloc} * P${iloc}y)"))
+tPropB[3][0].append(Template(" (${V}t - ${dot}*OM${iloc} * P${iloc}t) * (-1 - OM${iloc} * P${iloc}z ** 2) - OM${iloc} * P${iloc}t * P${iloc}z * (${V}z - ${dot}*OM${iloc} * P${iloc}z) / 3."))
+tPropB[3][1].append(Template("-OM${iloc} * P${iloc}t * P${iloc}z * (${V}x - ${dot}*OM${iloc} * P${iloc}x) - OM${iloc} * P${iloc}t * P${iloc}x * (${V}z - ${dot}*OM${iloc} * P${iloc}z) + 2. / 3. * (${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}x * P${iloc}z"))
+tPropB[3][1].append(Template(" -(${V}x - ${dot}*OM${iloc} * P${iloc}x)*OM${iloc} * P${iloc}x * P${iloc}z / 3. + (-1 - OM${iloc} * P${iloc}x ** 2) * (${V}z - ${dot}*OM${iloc} * P${iloc}z)"))
+tPropB[3][1].append(Template(" -(${V}x - ${dot}*OM${iloc} * P${iloc}x)*OM${iloc} * P${iloc}y * P${iloc}z - OM${iloc} * P${iloc}x * P${iloc}y * (${V}z - ${dot}*OM${iloc} * P${iloc}z) + 2. / 3.*OM${iloc} * P${iloc}x * P${iloc}z * (${V}y - ${dot}*OM${iloc} * P${iloc}y)"))
+tPropB[3][1].append(Template(" (${V}x - ${dot}*OM${iloc} * P${iloc}x) * (-1 - OM${iloc} * P${iloc}z ** 2) - OM${iloc} * P${iloc}x * P${iloc}z * (${V}z - ${dot}*OM${iloc} * P${iloc}z) / 3."))
+tPropB[3][2].append(Template(" -OM${iloc} * P${iloc}t * P${iloc}z * (${V}y - ${dot}*OM${iloc} * P${iloc}y) - OM${iloc} * P${iloc}t * P${iloc}y * (${V}z - ${dot}*OM${iloc} * P${iloc}z) + 2. / 3. * (${V}t - ${dot}*OM${iloc} * P${iloc}t)*OM${iloc} * P${iloc}y * P${iloc}z"))
+tPropB[3][2].append(Template("-OM${iloc} * P${iloc}x * P${iloc}z * (${V}y - ${dot}*OM${iloc} * P${iloc}y) - OM${iloc} * P${iloc}x * P${iloc}y * (${V}z - ${dot}*OM${iloc} * P${iloc}z) + 2. / 3. * (${V}x - ${dot}*OM${iloc} * P${iloc}x)*OM${iloc} * P${iloc}y * P${iloc}z"))
+tPropB[3][2].append(Template(" -(${V}y - ${dot}*OM${iloc} * P${iloc}y)*OM${iloc} * P${iloc}y * P${iloc}z / 3. + (-1 - OM${iloc} * P${iloc}y ** 2) * (${V}z - ${dot}*OM${iloc} * P${iloc}z)"))
+tPropB[3][2].append(Template(" (${V}y - ${dot}*OM${iloc} * P${iloc}y) * (-1 - OM${iloc} * P${iloc}z ** 2) - OM${iloc} * P${iloc}y * P${iloc}z * (${V}z - ${dot}*OM${iloc} * P${iloc}z) / 3."))
+tPropB[3][3].append(Template(" -2*OM${iloc} * P${iloc}t * P${iloc}z * (${V}z - ${dot}*OM${iloc} * P${iloc}z) - 2. / 3. * (${V}t - ${dot}*OM${iloc} * P${iloc}t) * (-1 - OM${iloc} * P${iloc}z ** 2)"))
+tPropB[3][3].append(Template("-2*OM${iloc} * P${iloc}x * P${iloc}z * (${V}z - ${dot}*OM${iloc} * P${iloc}z) - 2. / 3. * (${V}x - ${dot}*OM${iloc} * P${iloc}x) * (-1 - OM${iloc} * P${iloc}z ** 2)"))
+tPropB[3][3].append(Template("-2*OM${iloc} * P${iloc}y * P${iloc}z * (${V}z - ${dot}*OM${iloc} * P${iloc}z) - 2. / 3. * (${V}y - ${dot}*OM${iloc} * P${iloc}y) * (-1 - OM${iloc} * P${iloc}z ** 2)"))
+tPropB[3][3].append(Template("4. / 3. * (${V}z - ${dot}*OM${iloc} * P${iloc}z) * (-1 - OM${iloc} * P${iloc}z ** 2)"))
+
imap=["t","x","y","z"]
RSDotProduct = Template("${s}ts${si}*${v}t-${s}xs${si}*${v}x-${s}ys${si}*${v}y-${s}zs${si}*${v}z")
vTemplateT="""\
{header} {{
if({type}W{iloc}.id()=={id}) {{
return {normal};
}}
else {{
return {transpose};
}}
}};
"""
vTemplate4="""\
{header} {{
{swap}
if(id{iloc1}=={id1}) {{
if(id{iloc2}=={id2}) {{
return {res1};
}}
else {{
return {res2};
}}
}}
else {{
if(id{iloc2}=={id2}) {{
return {res3};
}}
else {{
return {res4};
}}
}}
}};
"""
vecTemplate="""\
+ Energy2 p2 = P{iloc}.m2();
LorentzPolarizationVector vtemp = {res};
- Energy2 p2 = P{iloc}.m2();
Complex fact = -Complex(0.,1.)*({cf})*propagator(iopt,p2,out,mass,width);
if(mass.real() < ZERO) mass = (iopt==5) ? ZERO : out->mass();
complex<Energy2> mass2 = sqr(mass);
if(mass.real()==ZERO) {{
vtemp =fact*vtemp;
}}
else {{
complex<Energy> dot = P{iloc}*vtemp;
vtemp = fact*(vtemp-dot/mass2*P{iloc});
}}
return VectorWaveFunction(P{iloc},out,vtemp.x(),vtemp.y(),vtemp.z(),vtemp.t());
"""
sTemplate="""\
+ Energy2 p2 = P{iloc}.m2();
if(mass.real() < ZERO) mass = (iopt==5) ? ZERO : out->mass();
- Energy2 p2 = P{iloc}.m2();
Complex fact = Complex(0.,1.)*({cf})*propagator(iopt,p2,out,mass,width);
Lorentz{offTypeA}<double> newSpin = fact*({res});
return {offTypeB}(P{iloc},out,newSpin);
"""
RSTemplate="""\
if(mass.real() < ZERO) mass = (iopt==5) ? ZERO : out->mass();
Energy2 p2 = P{iloc}.m2();
Complex fact = Complex(0.,-1.)*({cf})*propagator(iopt,p2,out,mass,width);
complex<InvEnergy> Omass = mass.real()==ZERO ? InvEnergy(ZERO) : 1./mass;
Lorentz{offTypeA}<double> newSpin = fact*({res});
return {offTypeB}(P{iloc},out,newSpin);
"""
scaTemplate="""\
if(mass.real() < ZERO) mass = (iopt==5) ? ZERO : out->mass();
Energy2 p2 = P{iloc}.m2();
Complex fact = Complex(0.,1.)*({cf})*propagator(iopt,p2,out,mass,width);
complex<double> output = fact*({res});
return ScalarWaveFunction(P{iloc},out,output);
"""
tenTemplate="""\
if(mass.real() < ZERO) mass = (iopt==5) ? ZERO : out->mass();
- InvEnergy2 OM{iloc} = mass.real()==ZERO ? InvEnergy2(ZERO) : 1./sqr(mass.real());
+ InvEnergy2 OM{iloc} = mass.real()==ZERO ? InvEnergy2(ZERO) : 1./sqr(mass.real());
+ Energy2 M{iloc}2 = sqr(mass.real());
Energy2 p2 = P{iloc}.m2();
Complex fact = Complex(0.,1.)*({cf})*propagator(iopt,p2,out,mass,width);
LorentzTensor<double> output = fact*({res});
return TensorWaveFunction(P{iloc},out,output);
"""
# various strings for matrixes
I4 = "Matrix([[1.,0,0,0],[0,1.,0,0],[0,0,1.,0],[0,0,0,1.]])"
G5 = "Matrix([[-1.,0,0,0],[0,-1.,0,0],[0,0,1.,0],[0,0,0,1.]])"
PM = "Matrix([[1.,0,0,0],[0,1.,0,0],[0,0,0,0],[0,0,0,0]])"
PP = "Matrix([[0,0,0,0],[0,0,0,0],[0,0,1.,0],[0,0,0,1.]])"
vslash = Template("Matrix([[0,0,${v}TMZ,-${v}XMY],[0,0,-${v}XPY,${v}TPZ],[${v}TPZ,${v}XMY,0,0],[${v}XPY,${v}TMZ,0,0]])")
vslashS = Template("${v}TPZ=Symbol(\"${v}TPZ\")\n${v}TMZ=Symbol(\"${v}TMZ\")\n${v}XPY=Symbol(\"${v}XPY\")\n${v}XMY=Symbol(\"${v}XMY\")\n")
momCom = Template("${v}t = Symbol(\"${v}t\")\n${v}x = Symbol(\"${v}x\")\n${v}y = Symbol(\"${v}y\")\n${v}z = Symbol(\"${v}z\")\n")
vslashD = Template("complex<${var}> ${v}TPZ = ${v}.t()+${v}.z();\n complex<${var}> ${v}TMZ = ${v}.t()-${v}.z();\n complex<${var}> ${v}XPY = ${v}.x()+Complex(0.,1.)*${v}.y();\n complex<${var}> ${v}XMY = ${v}.x()-Complex(0.,1.)*${v}.y();")
vslashM = Template("Matrix([[$m,0,${v}TMZ,-${v}XMY],[0,$m,-${v}XPY,${v}TPZ],[${v}TPZ,${v}XMY,$m,0],[${v}XPY,${v}TMZ,0,$m]])")
vslashM2 = Template("Matrix([[$m,0,-${v}TMZ,${v}XMY],[0,$m,${v}XPY,-${v}TPZ],[-${v}TPZ,-${v}XMY,$m,0],[-${v}XPY,-${v}TMZ,0,$m]])")
vslashMS = Template("${v}TPZ=Symbol(\"${v}TPZ\")\n${v}TMZ=Symbol(\"${v}TMZ\")\n${v}XPY=Symbol(\"${v}XPY\")\n${v}XMY=Symbol(\"${v}XMY\")\n${m}=Symbol(\"${m}\")\nO${m}=Symbol(\"O${m}\")\n")
rslash = Template("Matrix([[$m,0,${v}TMZ,-${v}XMY],[0,$m,-${v}XPY,${v}TPZ],[${v}TPZ,${v}XMY,$m,0],[${v}XPY,${v}TMZ,0,$m]])*( ($${eta}-2./3.*O${m}**2*${v}$${A}*${v}$${B})*Matrix([[1.,0,0,0],[0,1.,0,0],[0,0,1.,0],[0,0,0,1.]]) -1./3.*$${DA}*$${DB} -1./3.*O${m}*(${v}$${B}*$${DA}-${v}$${A}*$${DB}))")
rslashB = Template("Matrix([[$m,0,${v}TMZ,-${v}XMY],[0,$m,-${v}XPY,${v}TPZ],[${v}TPZ,${v}XMY,$m,0],[${v}XPY,${v}TMZ,0,$m]])*( (${v2}$${A}-2./3.*O${m}**2*${v}$${A}*${dot})*Matrix([[1.,0,0,0],[0,1.,0,0],[0,0,1.,0],[0,0,0,1.]]) -1./3.*$${DA}*${DB} -1./3.*O${m}*(${dot}*$${DA}-${v}$${A}*${DB}))")
rslash2 = Template("Matrix([[$m,0,-${v}TMZ,${v}XMY],[0,$m,${v}XPY,-${v}TPZ],[-${v}TPZ,-${v}XMY,$m,0],[-${v}XPY,-${v}TMZ,0,$m]])*( ($${eta}-2./3.*O${m}**2*${v}$${A}*${v}$${B})*Matrix([[1.,0,0,0],[0,1.,0,0],[0,0,1.,0],[0,0,0,1.]]) -1./3.*$${DA}*$${DB} +1./3.*O${m}*(${v}$${B}*$${DA}-${v}$${A}*$${DB}))")
rslash2B = Template("Matrix([[$m,0,-${v}TMZ,${v}XMY],[0,$m,${v}XPY,-${v}TPZ],[-${v}TPZ,-${v}XMY,$m,0],[-${v}XPY,-${v}TMZ,0,$m]])*( (${v2}$${B}-2./3.*O${m}**2*${dot}*${v}$${B})*Matrix([[1.,0,0,0],[0,1.,0,0],[0,0,1.,0],[0,0,0,1.]]) -1./3.*${DA}*$${DB} +1./3.*O${m}*(${v}$${B}*${DA}-${dot}*$${DB}))")
dirac=["Matrix([[0,0,1.,0],[0,0,0,1.],[1.,0,0,0],[0,1.,0,0]])","Matrix([[0,0,0,1.],[0,0,1.,0],[0,-1.,0,0],[-1.,0,0,0]])",
"Matrix([[0,0,0,complex(0, -1.)],[0,0,complex(0, 1.),0],[0,complex(0, 1.),0,0],[complex(0, -1.),0,0,0]])",
"Matrix([[0,0,1.,0],[0,0,0,-1.],[-1.,0,0,0],[0,1.,0,0]])"]
CC = "Matrix([[0,1.,0,0],[-1.,0,0,0],[0,0,0,-1.],[0,0,1.,0]])"
CD = "Matrix([[0,-1.,0,0],[1.,0,0,0],[0,0,0,1.],[0,0,-1.,0]])"
evaluateTemplate = """\
{decl} {{
{momenta}
{waves}
{swap}
{symbols}
{couplings}
{defns}
{result}
}}
"""
spinor = Template("Matrix([[${s}s1],[${s}s2],[${s}s3],[${s}s4]])")
sbar = Template("Matrix([[${s}s1,${s}s2,${s}s3,${s}s4]])")
sline = Template("${s}s1=Symbol(\"${s}s1\")\n${s}s2=Symbol(\"${s}s2\")\n${s}s3=Symbol(\"${s}s3\")\n${s}s4=Symbol(\"${s}s4\")\n")
RSSpinorTemplate = Template("${type}<double>(${outxs1},\n${outxs2},\n${outxs3},\n${outxs4},\n${outys1},\n${outys2},\n${outys3},\n${outys4},\n${outzs1},\n${outzs2},\n${outzs3},\n${outzs4},\n${outts1},\n${outts2},\n${outts3},\n${outts4})")
SpinorTemplate = Template("${type}<double>(${outs1},\n${outs2},\n${outs3},\n${outs4})")
class LorentzIndex :
""" A simple classs to store a Lorentz index """
type=""
value=0
dimension=0
def __repr__(self):
- return "%s%s" % (self.type,self.value)
+ if(self.type=="V" and not isinstance(self.value,int)) :
+ return self.value
+ else :
+ return "%s%s" % (self.type,self.value)
def __init__(self,val) :
if(isinstance(val,int)) :
self.dimension=0
if(val<0) :
self.type="D"
self.value = val
elif(val>0 and val/1000==0) :
self.type="E"
self.value = val
elif(val>0 and val/1000==1) :
self.type="T1"
self.value = val%1000
elif(val>0 and val/1000==2) :
self.type="T2"
self.value = val%1000
else :
print "INDEX",val
quit()
else :
print 'unknown value in lorentz index',val
quit()
def __eq__(self,other):
if(not isinstance(other,LorentzIndex)) :
return False
return ( (self.type, self.value)
== (other.type, other.value) )
def __hash__(self) :
return hash((self.type,self.value))
class DiracMatrix:
"""A simple class to store Dirac matrices"""
name =""
value=""
index=0
def __init(self) :
self.name=""
self.value=""
self.index=0
def __repr__(self) :
if(self.value==0) :
return "%s" % self.index
else :
return "%s" % self.value
class LorentzStructure:
"""A simple class to store a Lorentz structures"""
name=""
value=0
lorentz=[]
spin=[]
def __init(self) :
self.name=""
self.value=0
self.lorentz=[]
self.spin=[]
def __repr__(self):
output = self.name
if((self.name=="P" or self.name=="Tensor") and self.value!=0) :
output += "%s" % self.value
if(self.name=="int" or self.name=="sign") :
output += "=%s" % self.value
elif(len(self.spin)==0) :
output += "("
for val in self.lorentz :
output += "%s," % val
output=output.rstrip(",")
output+=")"
elif(len(self.lorentz)==0) :
output += "("
for val in self.spin :
output += "%s," % val
output=output.rstrip(",")
output+=")"
else :
output += "("
for val in self.lorentz :
output += "%s," % val
for val in self.spin :
output += "%s," % val
output=output.rstrip(",")
output+=")"
return output
def LorentzCompare(a,b) :
if(a.name=="int" and b.name=="int") :
return int(abs(b.value)-abs(a.value))
elif(a.name=="int") :
return -1
elif(b.name=="int") :
return 1
elif(len(a.spin)==0) :
if(len(b.spin)==0) :
return len(b.lorentz)-len(a.lorentz)
else :
return -1
elif(len(b.spin)==0) :
return 1
else :
if(len(a.spin)==0 or len(b.spin)==0) :
print 'index problem',a.name,b.name
print a.spin,b.spin
quit()
if(a.spin[0]>0 or b.spin[1]>0 ) : return -1
if(a.spin[1]>0 or b.spin[0]>0 ) : return 1
if(a.spin[1]==b.spin[0]) : return -1
if(b.spin[1]==a.spin[0]) : return 1
return 0
def extractIndices(struct) :
if(struct.find("(")<0) : return []
temp=struct.split("(")[1].split(")")[0].split(",")
output=[]
for val in temp :
output.append(int(val))
return output
def parse_structure(structure,spins) :
output=[]
found = True
while(found) :
found = False
# signs between terms
if(structure=="+" or structure=="-") :
output.append(LorentzStructure())
output[0].name="sign"
output[0].value=structure[0]+"1."
output[0].value=float(output[0].value)
output[0].lorentz=[]
output[0].spin=[]
return output
# simple numeric pre/post factors
elif((structure[0]=="-" or structure[0]=="+") and
structure[-1]==")" and structure[1]=="(") :
output.append(LorentzStructure())
output[-1].name="int"
output[-1].value=structure[0]+"1."
output[-1].value=float(output[-1].value)
output[-1].lorentz=[]
output[-1].spin=[]
structure=structure[2:-1]
found=True
elif(structure[0]=="(") :
temp=structure.rsplit(")",1)
structure=temp[0][1:]
output.append(LorentzStructure())
output[-1].name="int"
output[-1].value="1."+temp[1]
output[-1].value=float(eval(output[-1].value))
output[-1].lorentz=[]
output[-1].spin=[]
found=True
elif(structure[0:2]=="-(") :
temp=structure.rsplit(")",1)
structure=temp[0][2:]
output.append(LorentzStructure())
output[-1].name="int"
output[-1].value="-1."+temp[1]
output[-1].value=float(eval(output[-1].value))
output[-1].lorentz=[]
output[-1].spin=[]
found=True
# special handling for powers , assume only 2
power = False
if("**" in structure ) :
power = True
structure = structure.replace("**","^")
structures = structure.split("*")
if(power) :
for j in range(0,len(structures)):
if(structures[j].find("^")>=0) :
temp = structures[j].split("^")
structures[j] = temp[0]
for i in range(0,int(temp[1])-1) :
structures.append(temp[0])
# split up the structure
for struct in structures:
ind = extractIndices(struct)
# different types of object
# object with only spin indices
if(struct.find("Identity")==0 or
struct.find("Proj")==0 or
struct.find("Gamma5")==0) :
output.append(LorentzStructure())
output[-1].spin=ind
output[-1].lorentz=[]
output[-1].name=struct.split("(")[0]
output[-1].value=0
if(len(struct.replace("%s(%s,%s)" % (output[-1].name,ind[0],ind[1]),""))!=0) :
print "Problem handling %s structure " % output[-1].name
raise SkipThisVertex()
# objects with 2 lorentz indices
elif(struct.find("Metric")==0) :
output.append(LorentzStructure())
output[-1].lorentz=[LorentzIndex(ind[0]),LorentzIndex(ind[1])]
output[-1].name=struct.split("(")[0]
output[-1].value=0
output[-1].spin=[]
if(len(struct.replace("%s(%s,%s)" % (output[-1].name,ind[0],ind[1]),""))!=0) :
print "Problem handling %s structure " % output[-1].name
raise SkipThisVertex()
elif(struct.find("P(")==0) :
output.append(LorentzStructure())
output[-1].lorentz=[LorentzIndex(ind[0])]
output[-1].name=struct.split("(")[0]
output[-1].value=ind[1]
output[-1].spin=[]
if(len(struct.replace("%s(%s,%s)" % (output[-1].name,ind[0],ind[1]),""))!=0) :
print "Problem handling %s structure " % output[-1].name
raise SkipThisVertex()
# 1 lorentz and 1 spin index
elif(struct.find("Gamma")==0) :
output.append(LorentzStructure())
output[-1].lorentz=[LorentzIndex(ind[0])]
output[-1].spin=[ind[1],ind[2]]
output[-1].name=struct.split("(")[0]
output[-1].value=1
if(len(struct.replace("%s(%s,%s,%s)" % (output[-1].name,ind[0],ind[1],ind[2]),""))!=0) :
print "problem parsing gamma matrix",struct
raise SkipThisVertex()
# objects with 4 lorentz indices
elif(struct.find("Epsilon")==0) :
output.append(LorentzStructure())
output[-1].lorentz=[]
for i in range(0,len(ind)) :
output[-1].lorentz.append(LorentzIndex(ind[i]))
output[-1].spin=[]
output[-1].name=struct.split("(")[0]
output[-1].value=1
if(len(struct.replace("%s(%s,%s,%s,%s)" % (output[-1].name,ind[0],ind[1],ind[2],ind[3]),""))!=0) :
print 'problem parsing epsilon',struct
raise SkipThisVertex()
# scalars
else :
try :
output.append(LorentzStructure())
output[-1].value=float(struct)
output[-1].name="int"
output[-1].lorentz=[]
output[-1].spin=[]
except :
if(struct.find("complex")==0) :
vals = struct[0:-1].replace("complex(","").split(",")
output[-1].value=complex(float(vals[0]),float(vals[1]))
output[-1].name="int"
output[-1].lorentz=[]
output[-1].spin=[]
else :
print 'scalar problem',struct
print complex(struct)
quit()
# now do the sorting
if(len(output)==1) : return output
output = sorted(output,cmp=LorentzCompare)
# fix indices in the RS case
if(4 in spins) :
for i in range(0,len(output)) :
for ll in range(0,len(output[i].lorentz)) :
if(spins[output[i].lorentz[ll].value-1]==4 and
output[i].lorentz[ll].type=="E") :
output[i].lorentz[ll].type="R"
# return the answer
return output
def constructDotProduct(ind1,ind2,defns) :
(ind1,ind2) = sorted((ind1,ind2),cmp=indSort)
dimension=ind1.dimension+ind2.dimension
# this product already dealt with ?
if((ind1,ind2) in defns) :
name = defns[(ind1,ind2)][0]
# handle the product
else :
name = "dot%s" % (len(defns)+1)
unit = computeUnit(dimension)
defns[(ind1,ind2)] = [name,"complex<%s> %s = %s*%s;" % (unit,name,ind1,ind2)]
return (name,dimension)
def contract(parsed) :
for j in range(0,len(parsed)) :
if(parsed[j]=="") : continue
if(parsed[j].name=="P") :
# simplest case
if(parsed[j].lorentz[0].type=="E" or
parsed[j].lorentz[0].type=="P") :
newIndex = LorentzIndex(parsed[j].value)
newIndex.type="P"
newIndex.dimension=1
parsed[j].name="Metric"
parsed[j].lorentz.append(newIndex)
parsed[j].lorentz = sorted(parsed[j].lorentz,cmp=indSort)
continue
ll=1
found=False
for k in range(0,len(parsed)) :
if(j==k or parsed[k]=="" ) : continue
for i in range(0,len(parsed[k].lorentz)) :
if(parsed[k].lorentz[i] == parsed[j].lorentz[0]) :
parsed[k].lorentz[i].type="P"
parsed[k].lorentz[i].value = parsed[j].value
parsed[k].lorentz[i].dimension=1
if(parsed[k].name=="P") :
parsed[k].lorentz.append(LorentzIndex(parsed[k].value))
parsed[k].lorentz[1].type="P"
parsed[k].lorentz[1].dimension=1
parsed[k].name="Metric"
parsed[k].value = 0
found=True
break
if(found) :
parsed[j]=""
break
return [x for x in parsed if x != ""]
def computeUnit(dimension) :
if(isinstance(dimension,int)) :
dtemp = dimension
else :
dtemp=dimension[1]+dimension[2]
if(dtemp==0) :
unit="double"
elif(dtemp==1) :
unit="Energy"
elif(dtemp==-1) :
unit="InvEnergy"
elif(dtemp>0) :
unit="Energy%s" % (dtemp)
elif(dtemp<0) :
unit="InvEnergy%s" % (dtemp)
return unit
def computeUnit2(dimension,vDim) :
# first correct for any coupling power in vertex
totalDim = int(dimension[0])+dimension[2]+vDim-4
output=""
if(totalDim!=0) :
if(totalDim>0) :
if(totalDim==1) :
output = "1./GeV"
elif(totalDim==2) :
output = "1./GeV2"
else :
output="1."
for i in range(0,totalDim) :
output +="/GeV"
else :
if(totalDim==-1) :
output = "GeV"
elif(totalDim==-2) :
output = "GeV2"
else :
output="1."
for i in range(0,-totalDim) :
output +="*GeV"
expr=""
# now remove the remaining dimensionality
removal=dimension[1]-int(dimension[0])-vDim+4
if(removal!=0) :
if(removal>0) :
if(removal==1) :
expr = "UnitRemovalInvE"
else :
expr = "UnitRemovalInvE%s" % removal
else :
if(removal==-1) :
expr = "UnitRemovalE"
else :
expr = "UnitRemovalE%s" % (-removal)
if(output=="") : return expr
elif(expr=="") : return output
else : return "%s*%s" %(output,expr)
# order the indices of a dot product
def indSort(a,b) :
if(not isinstance(a,LorentzIndex) or
not isinstance(b,LorentzIndex)) :
quit()
if(a.type==b.type) :
i1=a.value
i2=b.value
if(i1>i2) :
return 1
elif(i1<i2) :
return -1
else :
return 0
else :
if(a.type=="E") :
return 1
else :
return -1
def finishParsing(parsed,dimension,lorentztag,iloc,defns,eps) :
output=1.
# replace signs
if(len(parsed)==1 and parsed[0].name=="sign") :
if(parsed[0].value>0) :
output="+"
else :
output="-"
parsed=[]
return (output,parsed,dimension,eps)
# replace integers (really lorentz scalars)
for j in range(0,len(parsed)) :
if(parsed[j]!="" and parsed[j].name=="int") :
output *= parsed[j].value
parsed[j]=""
# bracket this for safety
if(output!="") : output = "(%s)" % output
# special for tensor indices
if("T" in lorentztag) :
for j in range(0,len(parsed)) :
if(parsed[j]=="") :continue
# check for tensor index
found=False
for li in parsed[j].lorentz :
if(li.type[0]=="T") :
index = li
found=True
break
if(not found) : continue
# workout the other index for the tensor
index2 = LorentzIndex(li.value)
if(index.type=="T1") :
index2.type="T2"
else :
index2.type="T1"
# special is tensor contracted with itself
if(parsed[j].name=="Metric" and index2 == parsed[j].lorentz[1]) :
parsed[j].name = "Tensor"
parsed[j].value = index.value
parsed[j].lorentz = []
if(iloc!=index.value) :
name= "traceT%s" % parsed[j].value
if( name in defns ) :
output += "*(%s)" % defns[name][0]
else :
defns[name] = [name,"Complex %s = T%s.trace();" % (name,parsed[j].value)]
output += "*(%s)" % defns[name][0]
parsed[j]=""
continue
# otherwise search for the match
for k in range(j+1,len(parsed)) :
found = False
for li in parsed[k].lorentz :
if(li == index2) :
found=True
break
if(not found) : continue
if(parsed[j].name=="P") :
newIndex1 = LorentzIndex(parsed[j].value)
newIndex1.type="P"
newIndex1.dimension=1
elif(parsed[j].name=="Metric") :
for li in parsed[j].lorentz :
if(li != index) :
newIndex1=li
break
else :
- print 'unknown type'
+ print 'unknown type A'
print parsed[j]
quit()
if(parsed[k].name=="P") :
newIndex2 = LorentzIndex(parsed[k].value)
newIndex2.type="P"
newIndex2.dimension=1
elif(parsed[k].name=="Metric") :
for li in parsed[k].lorentz :
if(li != index) :
newIndex2=li
break
+ elif(parsed[k].name=="Gamma") :
+ if(index.value==iloc or (newIndex1.type=="E" and newIndex1.value==iloc)) :
+ newIndex2=index2
+ else :
+ unit="double"
+ dtemp=0
+ if(newIndex1.type=="P") :
+ dtemp += 1
+ unit="Energy"
+ if(index.type=="T1") :
+ name="T%s%sF" % (index.value,newIndex1)
+ defns[name] = [name,"LorentzVector<complex<%s> > %s = T%s.preDot(%s);" % (unit,name,index.value,newIndex1)]
+ else :
+ name="T%s%sS" % (index.value,newIndex1)
+ defns[name] = [name,"LorentzVector<complex<%s> > %s = T%s.postDot(%s);" % (unit,name,index.value,newIndex1)]
+ parsed[j]=""
+ gIndex=LorentzIndex(-1)
+ gIndex.type="V"
+ gIndex.value=name
+ gIndex.dimension=dtemp
+ parsed[k].lorentz[0] = gIndex
+ break
else :
- print 'unknown type'
- print parsed[j]
+ print 'unknown type B'
+ print parsed[j],parsed[k]
quit()
if(index2.type=="T1") :
newIndex1,newIndex2=newIndex2,newIndex1
parsed[j].name = "Tensor"
parsed[j].value= int(index.value)
parsed[j].lorentz= [newIndex1,newIndex2]
- parsed[k]=""
+ if(parsed[k].name!="Gamma") : parsed[k]=""
+ break
# main handling of lorentz structures
for j in range(0,len(parsed)) :
if(parsed[j]=="") : continue
if(parsed[j].name=="Metric") :
# check whether or not we can contract
canContract=True
for ll in parsed[j].lorentz :
if((ll.type=="E" and ll.value==iloc) or ll.type=="R") :
canContract = False
break
if(not canContract) : continue
# if we can do it
(name,dTemp) = constructDotProduct(parsed[j].lorentz[0],parsed[j].lorentz[1],defns)
output += "*(%s)" % name
dimension[2] += dTemp
parsed[j]=""
elif(parsed[j].name=="Epsilon") :
if(not eps) : eps = True
# work out which, if any of the indices can be summed over
summable=[]
for ix in range(0,len(parsed[j].lorentz)) :
if(parsed[j].lorentz[ix].type=="P" or
(parsed[j].lorentz[ix].type=="E" and iloc !=parsed[j].lorentz[ix].value)) :
summable.append(True)
else :
summable.append(False)
sc = summable.count(True)
if(sc<3) :
continue
elif(sc==3) :
offLoc = -1
for i in summable:
if(not summable[i]) :
offLoc = i
break
else :
offLoc = 0
indices=[]
dTemp=0
for ix in range(0,len(parsed[j].lorentz)) :
if(parsed[j].lorentz[ix].type=="P") : dTemp+=1
if(ix!=offLoc) : indices.append(parsed[j].lorentz[ix])
- dimension[2] += dTemp
if(sc==4) :
+ dimension[2] += dTemp
iTemp = (parsed[j].lorentz[0],parsed[j].lorentz[1],
parsed[j].lorentz[2],parsed[j].lorentz[3])
if(iTemp in defns) :
output += "*(%s)" % defns[iTemp][0]
parsed[j]=""
else :
name = "dot%s" % (len(defns)+1)
unit = computeUnit(dTemp)
defns[iTemp] = [name,"complex<%s> %s =-%s*epsilon(%s,%s,%s);" % (unit,name,parsed[j].lorentz[0],
indices[0],indices[1],indices[2]) ]
output += "*(%s)" % name
else :
iTemp = (indices[0],indices[1],indices[2])
sign = "1"
if(offLoc%2!=0) : sign="-1"
if(iTemp in defns) :
name = defns[iTemp][0]
else :
name = "V%s" % (len(defns)+1)
unit = computeUnit(dTemp)
defns[iTemp] = [name,"LorentzVector<complex<%s> > %s =-epsilon(%s,%s,%s);" % (unit,name,
indices[0],indices[1],indices[2]) ]
newIndex = LorentzIndex(int(name[1]))
newIndex.type="V"
newIndex.dimension=dTemp
output += "*(%s)" % (sign)
oi = parsed[j].lorentz[offLoc]
if(oi.type!="D") :
parsed[j].name="Metric"
parsed[j].spins=[]
parsed[j].value=0
parsed[j].lorentz=[newIndex,oi]
print 'replace with metric'
print parsed[j]
quit()
else :
found=False
for k in range(0,len(parsed)):
if(k==j or parsed[k]=="") : continue
for ll in range(0,len(parsed[k].lorentz)) :
if(parsed[k].lorentz[ll]==oi) :
found=True
parsed[k].lorentz[ll]=newIndex
break
if(found) : break
if(not found) :
print "problem in eps"
quit()
parsed[j]=""
elif(parsed[j].name=="Tensor") :
- # not an exteral tensor
+ # not an external tensor
if(parsed[j].value!=iloc) :
# now check the lorentz indices
con=[]
uncon=[]
dtemp=0
for li in parsed[j].lorentz :
- if(li.type=="P") :
+ if(li.type=="P" or li.type=="V") :
con.append(li)
- dtemp+=1
+ dtemp+=li.dimension
elif(li.type=="E") :
if(li.value!=iloc) :
con.append(li)
else :
uncon.append(li)
else :
print 'need to handle ',li,'in tensor',parsed[j]
print li
quit()
if(len(con)==2) :
iTemp = ("T%s%s%s"% (parsed[j].value,con[0],con[1]))
dimension[2]+=dtemp
if(iTemp in defns) :
output += "*(%s)" % defns[iTemp][0]
else :
unit=computeUnit(dtemp)
name = "dot%s" % (len(defns)+1)
defns[iTemp] = [name,"complex<%s> %s = T%s.preDot(%s)*%s;" % (unit,name,parsed[j].value,con[0],con[1])]
output += "*(%s)" % name
parsed[j]=""
# handled in final stage
elif(len(con)==1 and len(uncon)==1) :
continue
else :
print "can't happen"
quit()
- else :
- dtemp=0
- for li in parsed[j].lorentz :
- if(li.type=="P") : dtemp+=1
- dimension[2]+=dtemp
elif(parsed[j].name.find("Proj")>=0 or
- parsed[j].name.find("Gamma")>=0) :
+ parsed[j].name.find("Gamma")>=0 or
+ parsed[j].name.find("Identity")>=0) :
continue
elif(parsed[j].name=="P" and parsed[j].lorentz[0].type=="R") :
continue
else :
print 'not handled',parsed[j],iloc
quit()
# remove leading *
if(output!="" and output[0]=="*") : output = output[1:]
# remove any (now) empty elements
parsed = [x for x in parsed if x != ""]
return (output,parsed,dimension,eps)
def finalContractions(output,parsed,dimension,lorentztag,iloc,defns) :
if(len(parsed)==0) :
return (output,dimension)
elif(len(parsed)!=1) :
print "summation can't be handled",parsed,iloc,output
quit()
raise SkipThisVertex()
if(parsed[0].name=="Tensor") :
# contracted with off-shell vector
if(parsed[0].value!=iloc) :
found = False
for ll in parsed[0].lorentz :
if(ll.type=="E" and ll.value==iloc) :
found = True
else :
lo=ll
if(found) :
unit="double"
if(lo.type=="P") :
dimension[2]+=1
unit="Energy"
if(lo==parsed[0].lorentz[0]) :
name="T%s%sF" % (parsed[0].value,lo)
defns[name] = [name,"LorentzVector<complex<%s> > %s = T%s.preDot(%s);" % (unit,name,parsed[0].value,lo)]
else :
name="T%s%sS" % (parsed[0].value,lo)
defns[name] = [name,"LorentzVector<complex<%s> > %s = T%s.postDot(%s);" % (unit,name,parsed[0].value,lo)]
parsed[0]=""
if(output=="") : output="1."
output = "(%s)*(%s)" %(output,name)
else :
print 'problem with tensor',iloc
print parsed
quit()
# off-shell tensor
else :
+ if(len(parsed[0].lorentz)!=0) :
+ dimension[2]+=parsed[0].lorentz[0].dimension+parsed[0].lorentz[1].dimension
tensor = tensorPropagator(parsed[0],defns)
if(output=="") : output="1."
output = [output,tensor,()]
elif(parsed[0].name=="Metric") :
found = False
for ll in parsed[0].lorentz :
if(ll.type=="E" and ll.value==iloc) :
found = True
else :
lo=ll
if(found) :
parsed[0]=""
if(lo.type=="P") :
dimension[2]+=1
if(output=="") : output="1."
output = "(%s)*(%s)" %(output,lo)
else :
print "structure can't be handled",parsed,iloc
quit()
raise SkipThisVertex()
return (output,dimension)
def tensorPropagator(struct,defns) :
# dummy index
i0 = LorentzIndex(-1000)
# index for momentum of propagator
ip = LorentzIndex(struct.value)
ip.type="P"
ip.dimension=1
# the metric tensor
terms=[]
if(len(struct.lorentz)==0) :
(dp,dTemp) = constructDotProduct(ip,ip,defns)
pre = "-2./3.*(1.-%s*OM%s)" % (dp,struct.value)
terms.append((pre,i0,i0))
pre = "-4./3.*(1.-%s*OM%s)" % (dp,struct.value)
terms.append(("%s*OM%s" %(pre,struct.value),ip,ip))
else :
# indices of the tensor
ind1 = struct.lorentz[0]
ind2 = struct.lorentz[1]
# the dot products we need
(d1,dtemp) = constructDotProduct(ind1,ip,defns)
(d2,dtemp) = constructDotProduct(ind2,ip,defns)
(d3,dtemp) = constructDotProduct(ind1,ind2,defns)
# various terms in the propagator
terms.append(("1",ind1,ind2))
terms.append(("-OM%s*%s"%(struct.value,d1),ip,ind2))
terms.append(("-OM%s*%s"%(struct.value,d2),ind1,ip))
terms.append(("1",ind2,ind1))
terms.append(("-OM%s*%s"%(struct.value,d2),ip,ind1))
terms.append(("-OM%s*%s"%(struct.value,d1),ind2,ip))
terms.append(("-2./3.*"+d3,i0,i0))
terms.append(("2./3.*OM%s*%s*%s"%(struct.value,d1,d2),i0,i0))
terms.append(("2./3.*OM%s*%s"%(struct.value,d3),ip,ip))
terms.append(("4./3.*OM%s*OM%s*%s*%s"%(struct.value,struct.value,d1,d2),ip,ip))
# compute the output as a dict
output={}
for i1 in imap:
for i2 in imap :
val=""
for term in terms:
if(term[0][0]!="-") :
pre = "+"+term[0]
else :
pre = term[0]
if(term[1]==i0) :
if(i1==i2) :
if(i1=="t") :
val += pre
else :
if(pre[0]=="+") :
val +="-"+pre[1:]
else :
val +="+"+pre[1:]
else :
val += "%s*%s%s*%s%s" % (pre,term[1],i1,term[2],i2)
output["%s%s" % (i1,i2) ] = val.replace("+1*","+").replace("-1*","-")
return output
def generateVertex(iloc,L,parsed,lorentztag,vertex,defns) :
eps=False
# parse the lorentz structures
output = [1.]*len(parsed)
dimension=[]
for i in range(0,len(parsed)) :
dimension.append([0,0,0])
for i in range (0,len(parsed)) :
(output[i],parsed[i],dimension[i],eps) = finishParsing(parsed[i],dimension[i],lorentztag,iloc,defns,eps)
# still need to process gamma matrix strings for fermions
if(lorentztag[0] in ["F","R"] ) :
return convertDirac(output,dimension,eps,iloc,L,parsed,lorentztag,vertex,defns)
# return the answer
else :
handled=True
for i in range (0,len(parsed)) :
if(len(parsed[i])!=0) :
handled = False
break
if(not handled) :
for i in range (0,len(parsed)) :
(output[i],dimension[i]) = finalContractions(output[i],parsed[i],dimension[i],lorentztag,iloc,defns)
return (output,dimension,eps)
def convertDirac(output,dimension,eps,iloc,L,parsed,lorentztag,vertex,defns) :
for i in range(0,len(parsed)):
# skip empty elements
if(len(parsed[i])==0 or (len(parsed[i])==1 and parsed[i][0]=="")) : continue
# parse the string
(output[i],dimension[i],defns) = convertDiracStructure(parsed[i],output[i],dimension[i],
defns,iloc,L,lorentztag,vertex)
return (output,dimension,eps)
# parse the gamma matrices
def convertMatrix(structure,spins,unContracted,Symbols,dtemp,defns,iloc) :
i1 = structure.spin[0]
i2 = structure.spin[1]
if(structure.name=="Identity") :
output = DiracMatrix()
output.value = I4
output.index=0
output.name="M"
structure=""
elif(structure.name=="Gamma5") :
output = DiracMatrix()
output.value = G5
output.index=0
output.name="M"
structure=""
elif(structure.name=="ProjM") :
output = DiracMatrix()
output.value = PM
output.index=0
output.name="M"
structure=""
elif(structure.name=="ProjP") :
output = DiracMatrix()
output.value = PP
output.index=0
output.name="M"
structure=""
elif(structure.name=="Gamma") :
# gamma(mu) lorentz matrix contracted with dummy index
if(structure.lorentz[0].type=="D" or structure.lorentz[0].type=="R") :
if(structure.lorentz[0] not in unContracted) :
unContracted[structure.lorentz[0]] = 0
output = DiracMatrix()
output.value=0
output.index=structure.lorentz[0]
output.name="GMU"
structure=""
elif(structure.lorentz[0].type == "E" and
structure.lorentz[0].value == iloc ) :
if(structure.lorentz[0] not in unContracted) :
unContracted[structure.lorentz[0]] = 0
output = DiracMatrix()
output.value=0
output.index=structure.lorentz[0]
output.name="GMU"
structure=""
+ elif(structure.lorentz[0].type == "T1" or
+ structure.lorentz[0].type == "T2") :
+ if(structure.lorentz[0] not in unContracted) :
+ unContracted[structure.lorentz[0]] = 0
+ output = DiracMatrix()
+ output.value=0
+ output.index=structure.lorentz[0]
+ output.name="GMU"
+ structure=""
else :
output=DiracMatrix()
output.name="M"
output.value = vslash.substitute({ "v" : structure.lorentz[0]})
Symbols += vslashS.substitute({ "v" : structure.lorentz[0]})
variable = computeUnit(structure.lorentz[0].dimension)
- if(structure.lorentz[0].type!="V") :
- dtemp[2] += structure.lorentz[0].dimension
+ #if(structure.lorentz[0].type!="V" or
+ # structure.lorentz[0].type=="V") :
+ dtemp[2] += structure.lorentz[0].dimension
defns["vv%s" % structure.lorentz[0] ] = \
["vv%s" % structure.lorentz[0],
vslashD.substitute({ "var" : variable,
"v" : structure.lorentz[0]})]
structure=""
else :
print 'Unknown Gamma matrix structure',structure
quit()
return (i1,i2,output,structure,Symbols)
def checkRSContract(parsed,loc,dtemp) :
rindex=LorentzIndex(loc)
rindex.type="R"
contract=""
for i in range(0,len(parsed)) :
if(parsed[i]=="") : continue
found = False
for ll in range(0,len(parsed[i].lorentz)) :
if(parsed[i].lorentz[ll]==rindex) :
found=True
break
if(not found) :
continue
if(parsed[i].name=="P") :
dtemp[2]+=1
contract = LorentzIndex(parsed[i].value)
contract.type="P"
contract.dimension=1
parsed[i]=""
break
elif(parsed[i].name=="Metric") :
for ll in parsed[i].lorentz :
if(ll==rindex) :
continue
else :
break
if(ll.type=="P") :
dtemp[2]+=1
contract=ll
parsed[i]=""
break
elif(parsed[i].name=="Epsilon") :
continue
else :
print " CONT TEST A",parsed
print 'unkonwn type',parsed[i]
quit()
return contract
def processChain(dtemp,parsed,spins,Symbols,unContracted,defns,iloc) :
# piece of dimension which is common (0.5 for sbar and spinor)
dtemp[0]+=1
# set up the spin indices
sind = 0
lind = 0
expr=[]
# now find the next thing in the matrix string
ii = 0
index=0
while True :
# already handled
if(parsed[ii]=="") :
ii+=1
continue
# start of the chain
elif(sind==0 and len(parsed[ii].spin)==2 and parsed[ii].spin[0]>0 ) :
(sind,index,matrix,parsed[ii],Symbols) \
= convertMatrix(parsed[ii],spins,unContracted,Symbols,dtemp,defns,iloc)
expr.append(matrix)
# next element in the chain
elif(index!=0 and len(parsed[ii].spin)==2 and parsed[ii].spin[0]==index) :
(crap,index,matrix,parsed[ii],Symbols) \
= convertMatrix(parsed[ii],spins,unContracted,Symbols,dtemp,defns,iloc)
expr.append(matrix)
# check the index to see if we're at the end
if(index>0) :
lind=index
break
ii+=1
if(ii>=len(parsed)) :
print "Can't parsed the chain of dirac matrices"
+ print parsed
+ print expr
quit()
SkipThisVertex()
# start and end of the spin chains
# first particle spin 1/2
if(spins[sind-1]==2) :
start = DiracMatrix()
endT = DiracMatrix()
start.index=0
endT .index=0
# start of chain and end of transpose
# off shell
if(sind==iloc) :
start.name="M"
endT .name="M"
start.value = vslashM .substitute({ "v" : "P%s" % sind, "m" : "M%s" % sind} )
Symbols += vslashMS.substitute({ "v" : "P%s" % sind, "m" : "M%s" % sind} )
endT.value = vslashM2.substitute({ "v" : "P%s" % sind, "m" : "M%s" % sind} )
defns["vvP%s" % sind ] = ["vvP%s" % sind ,
vslashD.substitute({ "var" : "Energy",
"v" : "P%s" % sind })]
dtemp[1]+=1
# onshell
else :
start.name="S"
endT .name="S"
subs = {'s' : ("sbar%s" % sind)}
start.value = sbar .substitute(subs)
Symbols += sline.substitute(subs)
subs = {'s' : ("s%s" % sind)}
endT.value = spinor.substitute(subs)
Symbols += sline.substitute(subs) # start 3/2 and end 1/2
elif spins[sind-1]==4 :
# spin 3/2 fermion
# check if we can easily contract
contract=checkRSContract(parsed,sind,dtemp)
# off-shell
if(sind==iloc) :
oindex = LorentzIndex(sind)
oindex.type="O"
unContracted[oindex]=0
Symbols += vslashMS.substitute({ "v" : "P%s" % sind, "m" : "M%s" % sind} )
Symbols += momCom.substitute({"v" : "P%s" %sind })
defns["vvP%s" % sind ] = ["vvP%s" % sind ,
vslashD.substitute({ "var" : "Energy",
"v" : "P%s" % sind })]
dtemp[1] += 1
if(contract=="") :
rindex = LorentzIndex(sind)
rindex.type="R"
start=DiracMatrix()
start.value = Template(rslash.substitute({ "v" : "P%s" % sind, "m" : "M%s" % sind, "loc" : sind }))
start.name = "RP"
start.index = (oindex,rindex)
endT=DiracMatrix()
endT.value = Template(rslash2.substitute({ "v" : "P%s" % sind, "m" : "M%s" % sind, "loc" : sind }))
endT.name = "RP"
endT.index = (rindex,oindex)
else :
# construct dot product
pi = LorentzIndex(sind)
pi.type="P"
pi.dimension=1
(name,dummy) = constructDotProduct(pi,contract,defns)
Symbols += momCom.substitute({"v" : contract })
RB = vslash.substitute({ "v" : contract})
Symbols += vslashS.substitute({ "v" : contract })
Symbols += "%s = Symbol('%s')\n" % (name,name)
defns["vv%s" % contract ] = ["vv%s" % contract,
vslashD.substitute({ "var" : computeUnit(contract.dimension),
"v" : "%s" % contract })]
start=DiracMatrix()
start.name="RQ"
start.index = oindex
start.value =Template( rslashB.substitute({ "v" : "P%s" % sind, "m" : "M%s" % sind, "loc" : sind,
"DB" : RB, "dot" : name , "v2" : contract}))
endT=DiracMatrix()
endT.name = "RQ"
endT.index = oindex
endT.value = Template(rslash2B.substitute({ "v" : "P%s" % sind, "m" : "M%s" % sind, "loc" : sind ,
"DA" : RB, "dot" : name , "v2" : contract}))
# on-shell
else :
start = DiracMatrix()
endT = DiracMatrix()
# no contraction
if(contract=="" or (contract.type=="E" and contract.value==iloc) ) :
if contract == "" :
contract = LorentzIndex(sind)
contract.type="R"
# start of matrix string
start.value = Template(sbar .substitute({'s' : ("Rsbar%s${L}" % sind)}))
start.name="RS"
start.index = contract
# end of transpose string
endT.value=Template(spinor.substitute({'s' : ("Rs%s${L}" % sind)}))
endT.name="RS"
endT.index = contract
unContracted[contract]=0
# variables for sympy
for LI in imap :
Symbols += sline.substitute({'s' : ("Rs%s%s" % (sind,LI))})
Symbols += sline.substitute({'s' : ("Rsbar%s%s" % (sind,LI))})
else :
# start of matrix string
start.name="S"
start.value = "Matrix([[%s,%s,%s,%s]])" % (RSDotProduct.substitute({'s' : ("Rsbar%s" % sind), 'v':contract, 'si' : 1}),
RSDotProduct.substitute({'s' : ("Rsbar%s" % sind), 'v':contract, 'si' : 2}),
RSDotProduct.substitute({'s' : ("Rsbar%s" % sind), 'v':contract, 'si' : 3}),
RSDotProduct.substitute({'s' : ("Rsbar%s" % sind), 'v':contract, 'si' : 4}))
endT.name="S"
endT.value = "Matrix([[%s],[%s],[%s],[%s]])" % (RSDotProduct.substitute({'s' : ("Rs%s" % sind), 'v':contract, 'si' : 1}),
RSDotProduct.substitute({'s' : ("Rs%s" % sind), 'v':contract, 'si' : 2}),
RSDotProduct.substitute({'s' : ("Rs%s" % sind), 'v':contract, 'si' : 3}),
RSDotProduct.substitute({'s' : ("Rs%s" % sind), 'v':contract, 'si' : 4}))
Symbols += momCom.substitute({"v" : contract })
for LI in ["x","y","z","t"] :
Symbols += sline.substitute({'s' : ("Rs%s%s" % (sind,LI))})
Symbols += sline.substitute({'s' : ("Rsbar%s%s" % (sind,LI))})
# last particle spin 1/2
if( spins[lind-1]==2 ) :
end = DiracMatrix()
startT = DiracMatrix()
end .index=0
startT.index=0
# end of chain
if(lind==iloc) :
end.name ="M"
startT.name="M"
end.value = vslashM2.substitute({ "v" : "P%s" % lind, "m" : "M%s" % lind} )
startT.value = vslashM.substitute({ "v" : "P%s" % lind, "m" : "M%s" % lind} )
Symbols += vslashMS.substitute({ "v" : "P%s" % lind, "m" : "M%s" % lind} )
defns["vvP%s" % lind ] = ["vvP%s" % lind ,
vslashD.substitute({ "var" : "Energy",
"v" : "P%s" % lind })]
dtemp[1] += 1
else :
startT.name="S"
end .name="S"
subs = {'s' : ("s%s" % lind)}
end.value = spinor.substitute(subs)
Symbols += sline.substitute(subs)
subs = {'s' : ("sbar%s" % lind)}
startT.value = sbar .substitute(subs)
Symbols += sline.substitute(subs)
# last particle spin 3/2
elif spins[lind-1]==4 :
# check if we can easily contract
contract=checkRSContract(parsed,lind,dtemp)
# off-shell
if(lind==iloc) :
oindex = LorentzIndex(lind)
oindex.type="O"
unContracted[oindex]=0
Symbols += vslashMS.substitute({ "v" : "P%s" % lind, "m" : "M%s" % lind} )
Symbols += momCom.substitute({"v" : "P%s" %lind })
defns["vvP%s" % lind ] = ["vvP%s" % lind ,
vslashD.substitute({ "var" : "Energy",
"v" : "P%s" % lind })]
dtemp[1] += 1
if(contract=="") :
rindex = LorentzIndex(lind)
rindex.type="R"
end=DiracMatrix()
end.value = Template(rslash2.substitute({ "v" : "P%s" % lind, "m" : "M%s" % lind, "loc" : lind }))
end.name = "RP"
end.index = (rindex,oindex)
startT=DiracMatrix()
startT.value=Template(rslash.substitute({ "v" : "P%s" % lind, "m" : "M%s" % lind, "loc" : lind }))
startT.name = "RP"
startT.index = (oindex,rindex)
else :
# construct dot product
pi = LorentzIndex(lind)
pi.type="P"
pi.dimension=1
(name,unit) = constructDotProduct(pi,contract,defns)
Symbols += momCom.substitute({"v" : contract })
RB = vslash.substitute({ "v" : contract})
Symbols += vslashS.substitute({ "v" : contract })
Symbols += "%s = Symbol('%s')\n" % (name,name)
defns["vv%s" % contract ] = ["vv%s" % contract,
vslashD.substitute({ "var" : computeUnit(contract.dimension),
"v" : "%s" % contract })]
end=DiracMatrix()
end.name="RQ"
end.index = oindex
end.value =Template( rslash2B.substitute({ "v" : "P%s" % lind, "m" : "M%s" % lind, "loc" : lind,
"DA" : RB, "dot" : name , "v2" : contract}))
startT=DiracMatrix()
startT.name = "RQ"
startT.index = oindex
startT.value = Template(rslashB.substitute({ "v" : "P%s" % lind, "m" : "M%s" % lind, "loc" : lind ,
"DB" : RB, "dot" : name , "v2" : contract}))
# on-shell
else :
end = DiracMatrix()
startT = DiracMatrix()
# no contraction
if(contract=="" or (contract.type=="E" and contract.value==iloc) ) :
if contract == "" :
contract = LorentzIndex(lind)
contract.type="R"
# end of matrix string
end.value = Template(spinor.substitute({'s' : ("Rs%s${L}" % lind)}))
end.name = "RS"
end.index = contract
# start of matrix string
startT.value = Template(sbar .substitute({'s' : ("Rsbar%s${L}" % lind)}))
startT.name = "RS"
startT.index = contract
unContracted[contract]=0
# variables for sympy
for LI in imap :
Symbols += sline.substitute({'s' : ("Rs%s%s" % (lind,LI))})
Symbols += sline.substitute({'s' : ("Rsbar%s%s" % (lind,LI))})
# contraction
else :
# end of the matrix string
end.name = "S"
end.value = "Matrix([[%s],[%s],[%s],[%s]])" % (RSDotProduct.substitute({'s' : ("Rs%s" % lind), 'v':contract, 'si' : 1}),
RSDotProduct.substitute({'s' : ("Rs%s" % lind), 'v':contract, 'si' : 2}),
RSDotProduct.substitute({'s' : ("Rs%s" % lind), 'v':contract, 'si' : 3}),
RSDotProduct.substitute({'s' : ("Rs%s" % lind), 'v':contract, 'si' : 4}))
startT.name = "S"
startT.value = "Matrix([[%s,%s,%s,%s]])" % (RSDotProduct.substitute({'s' : ("Rsbar%s" % lind), 'v':contract, 'si' : 1}),
RSDotProduct.substitute({'s' : ("Rsbar%s" % lind), 'v':contract, 'si' : 2}),
RSDotProduct.substitute({'s' : ("Rsbar%s" % lind), 'v':contract, 'si' : 3}),
RSDotProduct.substitute({'s' : ("Rsbar%s" % lind), 'v':contract, 'si' : 4}))
Symbols += momCom.substitute({"v" : contract })
for LI in ["x","y","z","t"] :
Symbols += sline.substitute({'s' : ("Rs%s%s" % (lind,LI))})
Symbols += sline.substitute({'s' : ("Rsbar%s%s" % (lind,LI))})
return(sind,lind,expr,start,startT,end,endT,Symbols)
def calculateDirac(expr,start,end,startT,endT,sind,lind,Symbols,iloc) :
res=[]
for ichain in range(0,len(start)) :
# calculate the matrix string
etemp="*".join(str(x) for x in expr[ichain])
temp={}
exec("import sympy\nfrom sympy import Symbol,Matrix\n"+Symbols+"result="+
( "%s*%s*%s" %(start[ichain],etemp,end[ichain]))) in temp
res.append(temp["result"])
tempT={}
exec("import sympy\nfrom sympy import Symbol,Matrix,Transpose\n"+Symbols+"result="+
( "%s*%s*Transpose(%s)*%s*%s" %(startT[0],CC,etemp,CD,endT[0]))) in tempT
res.append(tempT["result"])
if(len(start)==1) :
if(iloc==0 or (iloc!=sind[0] and iloc!=lind[0])) :
sVal = {'s' : temp ["result"][0,0],'sT' : tempT["result"][0,0]}
else :
sVal={}
for jj in range(1,5) :
sVal["s%s" % jj] = temp ["result"][jj-1]
sVal["sT%s" % jj] = tempT["result"][jj-1]
else :
sVal={}
sVal["s" ] = res[0][0,0]*res[2][0,0]
sVal["sT2" ] = res[0][0,0]*res[3][0,0]
sVal["sT1" ] = res[1][0,0]*res[2][0,0]
sVal["sT12"] = res[1][0,0]*res[3][0,0]
return sVal
def addToOutput(res,nchain,sign,rTemp) :
# 1 spin chain
if(nchain==1) :
for ii in range(0,2) :
if(rTemp[ii][0].shape[0]==1) :
# result is scalar
if(rTemp[ii][0].shape[1]==1) :
if(len(res[ii])==0) :
res[ii].append(sign*rTemp [ii][0][0,0])
else :
res[ii][0] += sign*rTemp [ii][0][0,0]
# result is a spinor
elif(rTemp[ii][0].shape[1]==4) :
if(len(res[ii])==0) :
for j in range(0,4) :
res[ii].append(sign*rTemp[ii][0][0,j])
else :
for j in range(0,4) :
res[ii][j] += sign*rTemp[ii][0][0,j]
else :
print "SIZE PROBLEM A",sign,rTemp[ii].shape
quit()
raise SkipThisVertex()
# spinor
elif(rTemp[ii][0].shape[0]==4 and rTemp[ii][0].shape[1]==1 ) :
if(len(res[ii])==0) :
for j in range(0,4) :
res[ii].append(sign*rTemp[ii][0][j,0])
else :
for j in range(0,4) :
res[ii][j] += sign*rTemp[ii][0][j,0]
else :
print "SIZE PROBLEM B ",sign,rTemp[ii][0].shape
quit()
raise SkipThisVertex()
# 2 spin chains, should only be for a vertex
else :
for j1 in range(0,2) :
for j2 in range (0,2) :
val = sign*rTemp[j1][0]*rTemp[j2][1]
if(len(res[3])==0) :
res[2*j1+j2].append(val[0,0])
else :
res[2*j1+j2][0] += val[0,0]
def calculateDirac2(expr,start,end,startT,endT,sind,lind,Symbols,defns,
iloc,unContracted,spins,lorentz) :
+ tDot=""
# output
sVal={}
# no of chains
nchain=len(expr)
# now deal with the uncontracted cases
contracted={}
# sort out contracted and uncontracted indices
keys = unContracted.keys()
for key in keys:
# summed dummy index
if key.type=="D" :
contracted[key]=0
del unContracted[key]
# RS index
elif key.type =="R" :
contracted[key]=0
del unContracted[key]
+ # tensor index
+ elif key.type == "T1" or key.type=="T2" :
+ contracted[key]=0
+ del unContracted[key]
# external index
elif key.type == "O" :
continue
# uncontracted vector index
elif key.type=="E" or key.type=="Q":
continue
else :
- print 'uknown type of uncontracted index',key
+ print 'unknown type of uncontracted index',key
quit()
raise SkipThisVertex()
# check the lorentz structures
for lstruct in lorentz :
if(lstruct.name=="Epsilon" or
lstruct.name=="Vector") :
for index in lstruct.lorentz :
if(index.type=="E" and index.value==iloc) :
unContracted[index]=0
elif(index.type=="P" or index.type=="E"
or index.type=="R" or index.type=="D") :
contracted[index]=0
else :
print 'unknown index',index
quit()
+ elif(lstruct.name=="Tensor") :
+ if(iloc==lstruct.value) :
+ Symbols += momCom.substitute({"v": "P%s"%lstruct.value})
+ Symbols += "OM%s = Symbol(\"OM%s\")\n" % (lstruct.value,lstruct.value)
+ Symbols += "M%s2 = Symbol(\"M%s2\")\n" % (lstruct.value,lstruct.value)
+ Symbols += "p2 = Symbol(\"p2\")\n"
+ for ival in range(1,3) :
+ newIndex=LorentzIndex(ival)
+ newIndex.type="O"
+ newIndex.dimension=0
+ lstruct.lorentz.append(newIndex)
+ unContracted[newIndex]=0
+ if(len(lstruct.lorentz)==0) :
+ pass
+ elif lstruct.lorentz[0].type=="T1" and lstruct.lorentz[1].type=="T2":
+ print 'both uncontracted'
+ print 'unknown tensor object',lstruct,iloc
+ print lstruct.value
+ print lorentz
+ print expr
+ print start
+ print end
+ print defns
+ print contracted
+ print unContracted
+ quit()
+ elif lstruct.lorentz[0].type=="T1":
+ pIndex = LorentzIndex(lstruct.value)
+ pIndex.dimension=1
+ pIndex.type="P"
+ (tDot,dtemp) = constructDotProduct(pIndex,lstruct.lorentz[1],defns)
+ Symbols+="%s = Symbol(\"%s\")\n" %(tDot,tDot)
+ Symbols += momCom.substitute({"v": lstruct.lorentz[1]})
+ elif lstruct.lorentz[1].type=="T2" :
+ pIndex = LorentzIndex(lstruct.value)
+ pIndex.dimension=1
+ pIndex.type="P"
+ (tDot,dtemp) = constructDotProduct(pIndex,lstruct.lorentz[0],defns)
+ Symbols+="%s = Symbol(\"%s\")\n" %(tDot,tDot)
+ Symbols += momCom.substitute({"v": lstruct.lorentz[0]})
+ else :
+ print 'unknown tensor object',lstruct,iloc
+ print lstruct.value
+ print lorentz
+ print expr
+ print start
+ print end
+ quit()
else :
print 'unknown lorentz object',lstruct,iloc
print lstruct.value
print lorentz
print expr
print start
print end
quit()
# iterate over the uncontracted indices
while True :
# loop over the unContracted indices
res = []
for i in range(0,nchain) :
res.append([])
res.append([])
# loop over the contracted indices
while True :
# sign from metric tensor in contractions
sign = 1
for key,val in contracted.iteritems() :
if(val>0) : sign *=-1
eTemp =[]
sTemp =[]
fTemp =[]
sTTemp=[]
fTTemp=[]
# make the necessary replacements for remaining indices
for ichain in range(0,nchain) :
# compute the main expression
eTemp.append([])
for val in expr[ichain] :
# already a matrix
if(val.name=="M") :
eTemp[ichain].append(val)
# gamma(mu), replace with correct dirac matrix
elif(val.name=="GMU") :
if(val.index in contracted) :
eTemp[ichain].append(dirac[contracted[val.index]])
elif(val.index in unContracted) :
eTemp[ichain].append(dirac[unContracted[val.index]])
else :
print 'unknown index'
print val
print val.name
print val.value
print val.index
quit()
# unknown to be sorted out
else :
print 'unkonwn type in expr'
print val
print val.name
print val.value
print val.index
quit()
# start and end
# start
if(start[ichain].name=="S" or start[ichain].name=="M" ) :
sTemp.append(start[ichain].value)
elif(start[ichain].name=="RS") :
if(start[ichain].index in contracted) :
sTemp.append(start[ichain].value.substitute({"L" : imap[ contracted[start[ichain].index]] }))
else :
sTemp.append(start[ichain].value.substitute({"L" : imap[unContracted[start[ichain].index]] }))
elif(start[ichain].name=="RQ") :
i1 = unContracted[start[ichain].index]
sTemp.append(start[ichain].value.substitute({"A" : imap[i1], "DA" : dirac[i1] }))
elif(start[ichain].name=="RP") :
i1 = unContracted[start[ichain].index[0]]
i2 = contracted[start[ichain].index[1]]
eta=0
if(i1==i2) :
if(i1==0) : eta = 1
else : eta = -1
sTemp.append(start[ichain].value.substitute({"eta" : eta, "A":imap[i1] , "B":imap[i2] ,
"DA": dirac[i1], "DB": dirac[i2]}))
else :
print 'barred spinor not a spinor'
print start[ichain].name
print start[ichain].value
print start[ichain].index
quit()
if(startT[ichain].name=="S" or startT[ichain].name=="M" ) :
sTTemp.append(startT[ichain].value)
elif(startT[ichain].name=="RS") :
if(startT[ichain].index in contracted) :
sTTemp.append(startT[ichain].value.substitute({"L" : imap[ contracted[startT[ichain].index]] }))
else :
sTTemp.append(startT[ichain].value.substitute({"L" : imap[unContracted[startT[ichain].index]] }))
elif(startT[ichain].name=="RQ") :
i1 = unContracted[startT[ichain].index]
sTTemp.append(startT[ichain].value.substitute({"A" : imap[i1], "DA" : dirac[i1] }))
elif(startT[ichain].name=="RP") :
i1 = unContracted[startT[ichain].index[0]]
i2 = contracted[startT[ichain].index[1]]
eta=0
if(i1==i2) :
if(i1==0) : eta = 1
else : eta = -1
sTTemp.append(startT[ichain].value.substitute({"eta" : eta, "A":imap[i1] , "B":imap[i2] ,
"DA": dirac[i1], "DB": dirac[i2]}))
else :
print 'barred spinorT not a spinor'
print startT[ichain].name
print startT[ichain].value
print startT[ichain].index
quit()
# end
if(end[ichain].name=="S" or end[ichain].name=="M" ) :
fTemp.append(end[ichain].value)
elif(end[ichain].name=="RS") :
if(end[ichain].index in contracted) :
fTemp.append(end[ichain].value.substitute({"L" : imap[ contracted[end[ichain].index]] }))
else :
fTemp.append(end[ichain].value.substitute({"L" : imap[unContracted[end[ichain].index]] }))
elif(end[ichain].name=="RQ") :
i1 = unContracted[end[ichain].index]
fTemp.append(end[ichain].value.substitute({"B" : imap[i1], "DB": dirac[i1] }))
elif(end[ichain].name=="RP") :
i1 = contracted[end[ichain].index[0]]
i2 = unContracted[end[ichain].index[1]]
eta=0
if(i1==i2) :
if(i1==0) : eta = 1
else : eta = -1
fTemp.append(end[ichain].value.substitute({"eta" : eta, "A":imap[i1] , "B":imap[i2] ,
"DA": dirac[i1], "DB": dirac[i2]}))
else :
print 'spinor not a spinor'
print end[ichain].name
print end[ichain].value
print end[ichain].index
quit()
if(endT[ichain].name=="S" or endT[ichain].name=="M" ) :
fTTemp.append(endT[ichain].value)
elif(endT[ichain].name=="RS") :
if(endT[ichain].index in contracted) :
fTTemp.append(endT[ichain].value.substitute({"L" : imap[ contracted[endT[ichain].index]] }))
else :
fTTemp.append(endT[ichain].value.substitute({"L" : imap[unContracted[endT[ichain].index]] }))
elif(endT[ichain].name=="RQ") :
i1 = unContracted[endT[ichain].index]
fTTemp.append(endT[ichain].value.substitute({"B" : imap[i1], "DB": dirac[i1] }))
elif(endT[ichain].name=="RP") :
i1 = contracted[endT[ichain].index[0]]
i2 = unContracted[endT[ichain].index[1]]
eta=0
if(i1==i2) :
if(i1==0) : eta = 1
else : eta = -1
fTTemp.append(endT[ichain].value.substitute({"eta" : eta, "A":imap[i1] , "B":imap[i2] ,
"DA": dirac[i1], "DB": dirac[i2]}))
else :
print 'spinorT not a spinor'
print endT[ichain].name
print endT[ichain].value
print endT[ichain].index
quit()
# and none dirac lorentz structures
isZero = False
for li in lorentz:
# uncontracted vector
if(li.name=="Vector") :
index = unContracted[li.lorentz[0]]
Symbols += momCom.substitute({"v":li.value})
for ichain in range(0,nchain) :
eTemp[ichain].append("%s%s"% (li.value,imap[index]) )
elif(li.name=="Epsilon") :
value=""
ival=[]
for index in li.lorentz :
if(index in contracted) :
if(index.type=="P" or index.type=="E") :
value += "*%s%s" % (index,imap[contracted[index]])
ival.append(contracted[index])
elif(index.type=="R" or index.type=="D") :
ival.append(contracted[index])
else :
print 'unknown index in eps',index
quit()
elif(index in unContracted) :
ival.append(unContracted[index])
if(len(value)!=0 and value[0]=="*") :
value = value[1:]
eVal = epsValue[ival[0]][ival[1]][ival[2]][ival[3]]
if(eVal==0) :
isZero = True
else :
for ichain in range(0,nchain) :
eTemp[ichain].append("(%s*%s)"% (eVal,value) )
+ elif(li.name=="Tensor") :
+ if(li.lorentz[0] in unContracted and li.lorentz[1] in unContracted) :
+ value=tPropA[unContracted[li.lorentz[0]]][unContracted[li.lorentz[0]]].substitute({"iloc" : li.value})
+ for ichain in range(0,nchain) :
+ eTemp[ichain].append("(%s)"% (value) )
+ else :
+ if li.lorentz[0].type=="T1" and li.lorentz[1].type=="T2" :
+ print 'both uncontracted'
+ quit()
+ elif li.lorentz[0].type=="T1":
+ value=tPropB[unContracted[li.lorentz[2]]][unContracted[li.lorentz[3]]][contracted[li.lorentz[0]]].substitute({"iloc" : li.value,
+ "V" : li.lorentz[1],
+ "dot" : tDot})
+ elif li.lorentz[1].type=="T2" :
+ value=tPropB[unContracted[li.lorentz[2]]][unContracted[li.lorentz[3]]][contracted[li.lorentz[1]]].substitute({"iloc" : li.value,
+ "V" : li.lorentz[0],
+ "dot" : tDot})
+ else :
+ print 'both contracted'
+ quit()
+ for ichain in range(0,nchain) :
+ eTemp[ichain].append("(%s)"% (value) )
# unknown
else :
print 'unknown expression in lorentz loop'
print li.name
print li.value
quit()
raise SkipThisVertex()
# now evaluate the result
if(not isZero) :
rTemp =[[],[]]
for ichain in range(0,nchain) :
core = "*".join(str(x) for x in eTemp[ichain])
temp={}
exec("import sympy\nfrom sympy import Symbol,Matrix\n"+Symbols+"result="+
( "(%s)*(%s)*(%s)" %(sTemp[ichain],core,fTemp[ichain]))) in temp
rTemp[0].append(temp["result"])
temp={}
exec("import sympy\nfrom sympy import Symbol,Matrix,Transpose\n"+Symbols+"result="+
( "(%s)*(%s)*(Transpose(%s))*(%s)*(%s)" %(sTTemp[ichain],CC,core,CD,fTTemp[ichain]))) in temp
rTemp[1].append(temp["result"])
# and add it to the output
addToOutput(res,nchain,sign,rTemp)
#### END OF THE CONTRACTED LOOP #####
# increment the indices being summed over
keys=contracted.keys()
ii = len(keys)-1
while ii >=0 :
if(contracted[keys[ii]]<3) :
contracted[keys[ii]]+=1
break
else :
contracted[keys[ii]]=0
ii-=1
nZero=0
for (key,val) in contracted.iteritems() :
if(val==0) : nZero+=1
if(nZero==len(contracted)) : break
###### END OF THE UNCONTRACTED LOOP ######
# no uncontracted indices
if(len(unContracted)==0) :
if(len(res[0])==1) :
# scalar
if(len(res)==2) :
sVal["s" ] = res[0]
sVal["sT"] = res[1]
# 4 fermion
else :
sVal["s" ] = res[0]
sVal["sT2" ] = res[1]
sVal["sT1" ] = res[2]
sVal["sT12"] = res[3]
# spinor
elif(len(res[0])==4) :
for k in range(0,4) :
sVal[ "s%s" % (k+1) ] = res[0][k]
sVal[ "sT%s" % (k+1) ] = res[1][k]
else :
print 'sum problem',len(res),len(res[0])
quit()
break
# uncontracted indices
else :
istring = ""
for (key,val) in unContracted.iteritems() :
istring +=imap[val]
- if(len(istring)!=1) :
+ if(len(istring)>2) :
print 'index problem',istring
print unContracted
- print unI
quit()
sVal[istring] = res[0]
sVal[istring+"T"] = res[1]
# increment the unsummed indices
keys=unContracted.keys()
ii = len(keys)-1
while ii >=0 :
if(unContracted[keys[ii]]<3) :
unContracted[keys[ii]]+=1
break
else :
unContracted[keys[ii]]=0
ii-=1
nZero=0
for (key,val) in unContracted.iteritems() :
if(val==0) : nZero+=1
if(nZero==len(unContracted)) : break
# handle the vector case
- if( "t" in sVal ) :
+ if( "tt" in sVal) :
+ if(len(sVal)==32 and "tt" in sVal and len(sVal["tt"])==1) :
+ for key in sVal:
+ sVal[key] = sVal[key][0]
+ else :
+ print 'tensor'
+ print len(sVal)
+ quit()
+ elif( "t" in sVal ) :
# deal with pure vectors
if(len(sVal)==8 and "t" in sVal and len(sVal["t"])==1) :
pass
# RS spinors
elif(len(sVal)==8 and "t" in sVal and len(sVal["t"])==4) :
pass
else :
print sVal
print 'val problrm A',len(sVal)
quit()
else :
if("s" in sVal) :
for key in sVal:
sVal[key] = sVal[key][0]
return sVal
def convertDiracStructure(parsed,output,dimension,defns,iloc,L,lorentztag,vertex) :
# get the spins of the particles
spins = vertex.lorentz[0].spins
# check if we have one or two spin chains
nchain = (lorentztag.count("F")+lorentztag.count("R"))/2
# storage of the intermediate results
expr =[]
start =[]
end =[]
startT=[]
endT =[]
sind=[0]*nchain
lind=[0]*nchain
unContracted={}
Symbols=""
dtemp=[0,0,0]
# parse the dirac matrix strings
for ichain in range(0,nchain) :
expr .append([])
start .append("")
startT.append("")
end .append("")
endT .append("")
sind[ichain],lind[ichain],expr[ichain],start[ichain],startT[ichain],end[ichain],endT[ichain],Symbols =\
processChain(dtemp,parsed,spins,Symbols,unContracted,defns,iloc)
# clean up parsed
# check we've dealt with everything
parsed = [x for x in parsed if x != ""]
lorentz=[]
if(len(parsed)!=0) :
for i in range(0,len(parsed)) :
if(parsed[i].name=="Metric") :
found = False
for ll in parsed[i].lorentz :
if(ll.type=="E" and ll.value==iloc) :
found = True
un=ll
else :
lo=ll
if(found) :
lstruct = LorentzStructure()
lstruct.name="Vector"
lstruct.value=lo
lstruct.lorentz=[un]
lstruct.spin=[]
lorentz.append(lstruct)
parsed[i]=""
unContracted[un]=0
- if(lo.type=="P") : dimension[2]+=1
+ dimension[2] += lo.dimension
elif(parsed[i].name=="Epsilon") :
lstruct = LorentzStructure()
lstruct.name="Epsilon"
lstruct.lorentz=parsed[i].lorentz
lstruct.value=0
lstruct.spin=[]
for index in lstruct.lorentz:
if(index.type=="P") :
dimension[2]+=1
if( not index in defns) :
defns[(index,)]=["",""]
if(index.type=="P" or
(index.type=="E" and index.value!=iloc)) :
Symbols += momCom.substitute( {"v": index} )
lorentz.append(lstruct)
parsed[i]=""
+ elif(parsed[i].name=="Tensor") :
+ lstruct = LorentzStructure()
+ lstruct.name="Tensor"
+ lstruct.value=parsed[i].value
+ lstruct.lorentz=parsed[i].lorentz
+ lstruct.spin=[]
+ for index in parsed[i].lorentz:
+ dimension[2] += index.dimension
+ parsed[i]=""
+ lorentz.append(lstruct)
else :
print 'unknown lorentz structure',parsed[i]
+ print iloc
print parsed
print expr
print start
print end
quit()
parsed = [x for x in parsed if x != ""]
if(len(parsed)!=0) :
print expr
print "Can't parse ",parsed,iloc
quit()
raise SkipThisVertex()
sVal ={}
+ dimension = list(map(lambda x, y: x + y, dtemp, dimension))
# deal with the simplest case first
- if len(unContracted) == 0 :
+ if len(unContracted) == 0 and len(lorentz) == 0:
sVal = calculateDirac(expr,start,end,startT,endT,sind,lind,Symbols,iloc)
else :
sVal = calculateDirac2(expr,start,end,startT,endT,sind,lind,Symbols,defns,
iloc,unContracted,spins,lorentz)
# set up the output
old = output
if(nchain==1) :
output = [old,sVal,(lind[0],sind[0])]
else :
output = [old,sVal,(lind[0],sind[0],lind[1],sind[1])]
- dimension = list(map(lambda x, y: x + y, dtemp, dimension))
return (output,dimension,defns)
def convertLorentz(Lstruct,lorentztag,order,vertex,iloc,defns,evalVertex) :
eps = False
# split the structure into individual terms
structures=Lstruct.structure.split()
parsed=[]
# parse structures and convert lorentz contractions to dot products
for struct in structures :
ptemp = parse_structure(struct,Lstruct.spins)
parsed.append(contract(ptemp))
# now in a position to generate the code
vals=generateVertex(iloc,Lstruct,parsed,lorentztag,vertex,defns)
evalVertex.append((vals[0],vals[1]))
if(vals[2]) : eps=True
return eps
def swapOrder(vertex,iloc,momenta,fIndex) :
names=['','sca','sp','v']
waves=['','sca','' ,'E']
output=""
for i in range(1,4) :
ns = vertex.lorentz[0].spins.count(i)
if((ns<=1 and i!=2) or (ns<=2 and i==2)) : continue
if(i!=3 and i!=1) :
print 'swap problem',i
quit()
sloc=[]
for j in range(0,len(vertex.lorentz[0].spins)) :
if(vertex.lorentz[0].spins[j]==i) : sloc.append(j+1)
if iloc in sloc : sloc.remove(iloc)
if(len(sloc)==1) : continue
for j in range(0,len(sloc)) :
output += " long id%s = %sW%s.id();\n" % (sloc[j],names[i],sloc[j])
for j in range(0,len(sloc)) :
for k in range(j+1,len(sloc)) :
code = vertex.particles[sloc[j]-1].pdg_code
output += " if(id%s!=%s) {\n" % (sloc[j],code)
output += " swap(id%s,id%s);\n" % (sloc[j],sloc[k])
output += " swap(%s%s,%s%s);\n" % (waves[i],sloc[j],waves[i],sloc[k])
if(momenta[sloc[j]-1][0] or momenta[sloc[k]-1][0]) :
momenta[sloc[j]-1][0] = True
momenta[sloc[k]-1][0] = True
output += " swap(P%s,P%s);\n" % (sloc[j],sloc[k])
output += " };\n"
return output
def swapOrderFFFF(vertex,iloc,fIndex) :
output=""
for j in range(0,len(fIndex)) :
if(j%2==0) :
output += " SpinorWaveFunction s%s = sW%s;\n" % (fIndex[j],fIndex[j])
else :
output += " SpinorBarWaveFunction sbar%s = sbarW%s;\n" % (fIndex[j],fIndex[j])
for j in range(0,len(fIndex)) :
if(j%2==0) :
output += " long id%s = sW%s.id();\n" % (fIndex[j],fIndex[j])
else :
output += " long id%s = sbarW%s.id();\n" % (fIndex[j],fIndex[j])
for j in range(0,2) :
code = vertex.particles[fIndex[j]-1].pdg_code
output += " if(id%s!=%s) {\n" % (fIndex[j],code)
output += " swap(id%s,id%s);\n" % (fIndex[j],fIndex[j+2])
wave="s"
if(j==1) : wave = "sbar"
output += " swap(%s%s,%s%s);\n" % (wave,fIndex[j],wave,fIndex[j+2])
output += " };\n"
return output
def constructSignature(vertex,order,iloc,decls,momenta,waves,fIndex) :
nf=0
poff=""
offType="Complex"
for i in order :
spin = vertex.lorentz[0].spins[i-1]
if(i==iloc) :
if(spin==1) :
offType="ScalarWaveFunction"
elif(spin==2) :
if(i%2==1) :
offType="SpinorBarWaveFunction"
else :
offType="SpinorWaveFunction"
nf+=1
elif(spin==4) :
if(i%2==1) :
offType="RSSpinorBarWaveFunction"
else :
offType="RSSpinorWaveFunction"
nf+=1
elif(spin==3) :
offType="VectorWaveFunction"
elif(spin==5) :
offType="TensorWaveFunction"
else :
print 'unknown spin',spin
quit()
momenta.append([False,""])
else :
if(spin==1) :
decls.append("ScalarWaveFunction & scaW%s" % (i))
momenta.append([False,"Lorentz5Momentum P%s =-scaW%s.momentum();" % (i,i)])
waves.append("Complex sca%s = scaW%s.wave();" % (i,i))
elif(spin==2) :
if(i%2==1) :
decls.append("SpinorWaveFunction & sW%s" % (fIndex[i-1]))
momenta.append([False,"Lorentz5Momentum P%s =-sW%s.momentum();" % (fIndex[i-1],fIndex[i-1])])
waves.append("LorentzSpinor<double> s%s = sW%s.wave();" % (fIndex[i-1],fIndex[i-1]))
nf+=1
else :
decls.append("SpinorBarWaveFunction & sbarW%s" % (fIndex[i-1]))
momenta.append([False,"Lorentz5Momentum P%s =-sbarW%s.momentum();" % (fIndex[i-1],fIndex[i-1])])
waves.append("LorentzSpinorBar<double> sbar%s = sbarW%s.wave();" % (fIndex[i-1],fIndex[i-1]))
nf+=1
elif(spin==3) :
decls.append("VectorWaveFunction & vW%s" % (i))
momenta.append([False,"Lorentz5Momentum P%s =-vW%s.momentum();" % (i,i)])
waves.append("LorentzPolarizationVector E%s = vW%s.wave();" % (i,i))
elif(spin==4) :
if(i%2==1) :
decls.append("RSSpinorWaveFunction & RsW%s" % (i))
momenta.append([False,"Lorentz5Momentum P%s =-RsW%s.momentum();" % (i,i)])
waves.append("LorentzRSSpinor<double> Rs%s = RsW%s.wave();" % (i,i))
nf+=1
else :
decls.append("RSSpinorBarWaveFunction & RsbarW%s" % (i))
momenta.append([False,"Lorentz5Momentum P%s =-RsbarW%s.momentum();" % (i,i)])
waves.append("LorentzRSSpinorBar<double> Rsbar%s = RsbarW%s.wave();" % (i,i))
nf+=1
elif(spin==5) :
decls.append("TensorWaveFunction & tW%s" % (i))
momenta.append([False,"Lorentz5Momentum P%s =-tW%s.momentum();" % (i,i)])
waves.append("LorentzTensor<double> T%s = tW%s.wave();" % (i,i))
else :
print 'unknown spin',spin
quit()
poff += "-P%s" % (i)
# ensure unbarred spinor first
ibar=-1
isp=-1
for i in range(0,len(decls)) :
if(decls[i].find("Bar")>0 and ibar==-1) :
ibar=i
elif(decls[i].find("Spinor")>=0 and isp==-1) :
isp=i
if(isp!=-1 and ibar!=-1 and isp>ibar) :
decls[ibar],decls[isp] = decls[isp],decls[ibar]
# constrct the signature
poff = ("Lorentz5Momentum P%s = " % iloc ) + poff
sig=""
if(iloc==0) :
sig="%s evaluate(Energy2, const %s)" % (offType,", const ".join(decls))
# special for VVT vertex
if(len(vertex.lorentz[0].spins)==3 and vertex.lorentz[0].spins.count(3)==2 and
vertex.lorentz[0].spins.count(5)==1) :
sig = sig[0:-1] + ", Energy vmass=-GeV)"
else :
sig="%s evaluate(Energy2, int iopt, tcPDPtr out, const %s, complex<Energy> mass=-GeV, complex<Energy> width=-GeV)" % (offType,", const ".join(decls))
momenta.append([True,poff+";"])
# special for VVT vertex
if(len(vertex.lorentz[0].spins)==3 and vertex.lorentz[0].spins.count(3)==2 and
vertex.lorentz[0].spins.count(5)==1 and vertex.lorentz[0].spins[iloc-1]==5) :
sig=sig.replace("complex<Energy> mass=-GeV","Energy vmass=-GeV, complex<Energy> mass=-GeV")
for i in range(0,len(momenta)) : momenta[i][0]=True
return offType,nf,poff,sig
def combineResult(res,nf,ispin,vertex) :
# extract the vals and dimensions
(vals,dim) = res
# construct the output structure
# vertex and off-shell scalars
if(ispin<=1) :
otype={'res':""}
# spins
elif(ispin==2) :
otype={'s1':"",'s2':"",'s3':"",'s4':""}
# vectors
elif(ispin==3) :
if( "t" in vals[0][1] ) :
otype={'t':"",'x':"",'y':"",'z':""}
else :
otype={"res":""}
# RS spinors
elif(ispin==4) :
otype={}
for i1 in imap :
for i in range(1,5) :
otype["%ss%s"% (i1,i)]=""
# off-shell tensors
elif(ispin==5) :
otype={}
for i1 in imap :
for i2 in imap :
otype["%s%s"%(i1,i2)]=""
else :
print vals
print 'spin problem',ispin
quit()
expr=[otype]
for i in range(0,nf-1) :
expr.append(copy.copy(otype))
# dimension for checking
dimCheck=dim[0]
for i in range(0,len(vals)) :
# simple signs
if(vals[i]=="+" or vals[i]=="-") :
for ii in range(0,len(expr)) :
for(key,val) in expr[ii].iteritems() :
expr[ii][key] = expr[ii][key]+vals[i]
continue
# check the dimensions
if(dimCheck[0]!=dim[i][0] or dimCheck[1]!=dim[i][1] or
dimCheck[2]!=dim[i][2]) :
print vertex.lorentz
for j in range(0,len(vals)) :
- print dim[j],vals[j]
+ print j,dim[j],vals[j]
print "DIMENSION PROBLEM",i,dimCheck,dim,vertex
quit()
# simplest case
if(isinstance(vals[i], basestring)) :
for ii in range(0,len(expr)) :
for(key,val) in expr[ii].iteritems() :
expr[ii][key] = expr[ii][key]+vals[i]
continue
# more complex structures
pre = vals[i][0]
if(pre=="(1.0)") : pre=""
if(not isinstance(vals[i][1],dict)) :
print 'must be a dict here'
raise SkipThisVertex()
# tensors
if("tt" in vals[i][1]) :
for i1 in imap :
for i2 in imap :
key="%s%s"%(i1,i2)
if(pre=="") :
expr[0][key] += "(%s)" % vals[i][1][key]
else :
expr[0][key] += "%s*(%s)" % (pre,vals[i][1][key])
if(len(expr)==2) :
if(pre=="") :
expr[1][key] +="(%s)" % vals[i][1][key+"T"]
else :
expr[1][key] +="%s*(%s)" % (pre,vals[i][1][key+"T"])
# standard fermion vertex case
elif(len(vals[i][1])==2 and "s" in vals[i][1] and "sT" in vals[i][1]) :
if(pre=="") :
expr[0]["res"] += "(%s)" % vals[i][1]["s"]
expr[1]["res"] += "(%s)" % vals[i][1]["sT"]
else :
expr[0]["res"] += "%s*(%s)" % (pre,vals[i][1]["s"])
expr[1]["res"] += "%s*(%s)" % (pre,vals[i][1]["sT"])
# spinor case
elif(len(vals[i][1])==8 and "s1" in vals[i][1]) :
for jj in range(1,5) :
if(pre=="") :
expr[0]["s%s" % jj] += "(%s)" % vals[i][1]["s%s" % jj]
expr[1]["s%s" % jj] += "(%s)" % vals[i][1]["sT%s" % jj]
else :
expr[0]["s%s" % jj] += "%s*(%s)" % (pre,vals[i][1]["s%s" % jj])
expr[1]["s%s" % jj] += "%s*(%s)" % (pre,vals[i][1]["sT%s" % jj])
# vector
elif(len(vals[i][1])%4==0 and "t" in vals[i][1] and len(vals[i][1]["t"])==1 ) :
for i1 in imap :
if(pre=="") :
expr[0][i1] += "(%s)" % vals[i][1][i1][0]
else :
expr[0][i1] += "%s*(%s)" % (pre,vals[i][1][i1][0])
if(len(expr)==2) :
if(pre=="") :
expr[1][i1] +="(%s)" % vals[i][1][i1+"T"][0]
else :
expr[1][i1] +="%s*(%s)" % (pre,vals[i][1][i1+"T"][0])
# 4 fermion vertex case
elif(len(vals[i][1])==4 and "sT12" in vals[i][1]) :
if(pre=="") :
expr[0]["res"] += "(%s)" % vals[i][1]["s"]
expr[1]["res"] += "(%s)" % vals[i][1]["sT2"]
expr[2]["res"] += "(%s)" % vals[i][1]["sT1"]
expr[3]["res"] += "(%s)" % vals[i][1]["sT12"]
else :
expr[0]["res"] += "%s*(%s)" % (pre,vals[i][1]["s"])
expr[1]["res"] += "%s*(%s)" % (pre,vals[i][1]["sT2"])
expr[2]["res"] += "(%s)" % vals[i][1]["sT1"]
expr[3]["res"] += "(%s)" % vals[i][1]["sT12"]
# RS spinor
elif(len(vals[i][1])%4==0 and "t" in vals[i][1] and len(vals[i][1]["t"])==4 ) :
for i1 in imap :
for k in range(1,5) :
key = "%ss%s" % (i1,k)
if(pre=="") :
expr[0][key] += "(%s)" % vals[i][1][i1][k-1]
expr[1][key] += "(%s)" % vals[i][1][i1+"T"][k-1]
else :
expr[0][key] += "%s*(%s)" % (pre,vals[i][1][i1][k-1])
expr[1][key] += "%s*(%s)" % (pre,vals[i][1][i1+"T"][k-1])
else :
print vals[i]
print 'problem with type'
quit()
# no of particles in the vertex
vDim = len(vertex.lorentz[0].spins)
# compute the unit and apply it
unit = computeUnit2(dimCheck,vDim)
if(unit!="") :
for ii in range(0,len(expr)) :
for (key,val) in expr[ii].iteritems() :
expr[ii][key] = "(%s)*(%s)" % (val,unit)
return expr
def headerReplace(inval) :
return inval.replace("virtual","").replace("ScalarWaveFunction","").replace("SpinorWaveFunction","") \
.replace("SpinorBarWaveFunction","").replace("VectorWaveFunction","").replace("TensorWaveFunction","") \
.replace("Energy2","q2").replace("int","").replace("complex<Energy>","").replace("Energy","").replace("=-GeV","") \
.replace("const &","").replace("tcPDPtr","").replace(" "," ").replace("Complex","")
def combineComponents(result,offType,RS) :
for i in range(0,len(result)) :
for (key,value) in result[i].iteritems() :
output=py2cpp(value.strip(),True)
result[i][key]=output[0]
# simplest case, just a value
if(len(result[0])==1 and "res" in result[0]) :
for i in range(0,len(result)) :
result[i] = result[i]["res"]
result[i]=result[i].replace("1j","ii")
return
# calculate the substitutions
if(not isinstance(result[0],basestring)) :
subs=[]
for ii in range(0,len(result)) :
subs.append({})
for (key,val) in result[ii].iteritems() :
subs[ii]["out%s" % key]= val
# spinors
if("s1" in result[0]) :
stype = "LorentzSpinor"
sbtype = "LorentzSpinorBar"
if(offType.find("Bar")>0) : (stype,sbtype)=(sbtype,stype)
subs[0]["type"] = stype
result[0] = SpinorTemplate.substitute(subs[0])
subs[1]["type"] = sbtype
result[1] = SpinorTemplate.substitute(subs[1])
# tensors
elif("tt" in result[0]) :
for ii in range(0,len(result)) :
result[ii] = Template("LorentzTensor<double>(${outxx},\n${outxy},\n${outxz},\n${outxt},\n${outyx},\n${outyy},\n${outyz},\n${outyt},\n${outzx},\n${outzy},\n${outzz},\n${outzt},\n${outtx},\n${outty},\n${outtz},\n${outtt})").substitute(subs[ii])
result[ii]=result[ii].replace("(+","(")
# vectors
elif("t" in result[0]) :
for ii in range(0,len(result)) :
result[ii] = Template("LorentzVector<Complex>(${outx},\n${outy},\n${outz},\n${outt})").substitute(subs[ii])
result[ii]=result[ii].replace("(+","(")
# RS spinors
elif("ts1" in result[0]) :
stype = "LorentzRSSpinor"
sbtype = "LorentzRSSpinorBar"
if(offType.find("Bar")>0) : (stype,sbtype)=(sbtype,stype)
subs[0]["type"] = stype
result[0] = RSSpinorTemplate.substitute(subs[0])
subs[1]["type"] = sbtype
result[1] = RSSpinorTemplate.substitute(subs[1])
else :
print subs[0]
print result
print 'type not implemented'
quit()
for i in range(0,len(result)) :
result[i]=result[i].replace("1j","ii")
def generateEvaluateFunction(model,vertex,iloc,values,defns,vertexEval,cf,order) :
RS = "R" in vertex.lorentz[0].name
FM = "F" in vertex.lorentz[0].name
# extract the start and end of the spin chains
if( RS or FM ) :
fIndex = vertexEval[0][0][0][2]
else :
fIndex=0
# first construct the signature of the function
decls=[]
momenta=[]
waves=[]
offType,nf,poff,sig = constructSignature(vertex,order,iloc,decls,momenta,waves,fIndex)
# combine the different terms in the result
symbols=set()
localCouplings=[]
result=[]
ispin = 0
if(iloc!=0) :
ispin = vertex.lorentz[0].spins[iloc-1]
# put the lorentz structures and couplings together
for j in range(0,len(vertexEval)) :
# get the lorentz structure piece
expr = combineResult(vertexEval[j],nf,ispin,vertex)
# get the coupling for this bit
val, sym = py2cpp(values[j])
localCouplings.append("Complex local_C%s = %s;\n" % (j,val))
symbols |=sym
# put them together
vtype="Complex"
if("res" in expr[0] and offType=="VectorWaveFunction") :
vtype="LorentzPolarizationVector"
if(len(result)==0) :
for ii in range(0,len(expr)) :
result.append({})
for (key,val) in expr[ii].iteritems() :
result[ii][key] = " %s((local_C%s)*(%s)) " % (vtype,j,val)
else :
for ii in range(0,len(expr)) :
for (key,val) in expr[ii].iteritems():
result[ii][key] += " + %s((local_C%s)*(%s)) " % (vtype,j,val)
# for more complex types merge the spin/lorentz components
combineComponents(result,offType,RS)
# multiple by scalar wavefunctions
scalars=""
for i in range (0,len(vertex.lorentz[0].spins)) :
if(vertex.lorentz[0].spins[i]==1 and i+1!=iloc) :
scalars += "sca%s*" % (i+1)
if(scalars!="") :
for ii in range(0,len(result)) :
result[ii] = "(%s)*(%s)" % (result[ii],scalars[0:-1])
# vertex, just return the answer
if(iloc==0) :
result[0] = "return (%s)*(%s);\n" % (result[0],py2cpp(cf)[0])
if(FM or RS) :
for i in range(1,len(result)) :
result[i] = "return (%s)*(%s);\n" % (result[i],py2cpp(cf)[0])
# off-shell particle
else :
# off-shell scalar
if(vertex.lorentz[0].spins[iloc-1] == 1 ) :
result[0] = scaTemplate.format(iloc=iloc,cf=py2cpp(cf[0])[0],res=result[0])
if(FM or RS) :
result[1] = scaTemplate.format(iloc=iloc,cf=py2cpp(cf[0])[0],res=result[1])
# off-shell fermion
elif(vertex.lorentz[0].spins[iloc-1] == 2 ) :
result[0] = sTemplate.format(iloc=iloc,cf=py2cpp(cf[0])[0],offTypeA=offType.replace("WaveFunction",""),
res=result[0].replace( "M%s" % iloc, "mass" ),offTypeB=offType)
if(FM or RS) :
if(offType.find("Bar")>0) :
offTypeT=offType.replace("Bar","")
else :
offTypeT=offType.replace("Spinor","SpinorBar")
result[1] = sTemplate.format(iloc=iloc,cf=py2cpp(cf[0])[0],offTypeA=offTypeT.replace("WaveFunction",""),
res=result[1].replace( "M%s" % iloc, "mass" ),offTypeB=offTypeT)
# off-shell vector
elif(vertex.lorentz[0].spins[iloc-1] == 3 ) :
result[0] = vecTemplate.format(iloc=iloc,res=result[0],cf=py2cpp(cf)[0])
if(FM or RS) :
result[1] = vecTemplate.format(iloc=iloc,cf=py2cpp(cf[0])[0],res=result[1])
elif(vertex.lorentz[0].spins[iloc-1] == 4 ) :
if(offType.find("Bar")>0) :
offTypeT=offType.replace("Bar","")
else :
offTypeT=offType.replace("Spinor","SpinorBar")
result[1] = RSTemplate.format(iloc=iloc,cf=py2cpp(cf[0])[0],offTypeA=offTypeT.replace("WaveFunction",""),
res=result[1].replace( "M%s" % iloc, "mass" ),offTypeB=offTypeT)
result[0] = RSTemplate.format(iloc=iloc,cf=py2cpp(cf[0])[0],offTypeA=offType.replace("WaveFunction",""),
res=result[0].replace( "M%s" % iloc, "mass" ),offTypeB=offType)
# tensors
elif(vertex.lorentz[0].spins[iloc-1]) :
if(RS) :
print "RS spinors and tensors not handled"
quit()
result[0] = tenTemplate.format(iloc=iloc,cf=py2cpp(cf)[0],res=result[0])
if(FM or RS) :
- result[1] = [tenTemplate.format(iloc=iloc,cf=py2cpp(cf)[0],res=result[1])]
+ result[1] = tenTemplate.format(iloc=iloc,cf=py2cpp(cf)[0],res=result[1])
else :
print 'unknown spin for off-shell particle',vertex.lorentz[0].spins[iloc-1]
quit()
# check if momenta defns needed to clean up compile of code
for (key,val) in defns.iteritems() :
if( isinstance(key, basestring)) :
if(key.find("vvP")==0) :
momenta[int(key[3])-1][0] = True
else :
for vals in key :
if(vals.type=="P") :
momenta[vals.value-1][0] = True
# cat the definitions
defString=""
for (key,value) in defns.iteritems() :
if(value[0]=="") : continue
- if(value[0][0]=="V") :
+ if(value[0][0]=="V" or value[0][0]=="T") :
defString+=" %s\n" %value[1]
for (key,value) in defns.iteritems() :
if(value[0]=="") : continue
- if(value[0][0]!="V") :
+ if(value[0][0]!="V" and value[0][0]!="T") :
defString+=" %s\n" %value[1]
if(len(result)<=2) :
sorder=swapOrder(vertex,iloc,momenta,fIndex)
else :
sorder=""
momentastring=""
for i in range(0,len(momenta)) :
if(momenta[i][0] and momenta[i][1]!="") :
momentastring+=momenta[i][1]+"\n "
# special for 4-point VVVV
if(vertex.lorentz[0].spins.count(3)==4 and iloc==0) :
sig=sig.replace("Energy2","Energy2,int")
header="virtual %s" % sig
sig=sig.replace("=-GeV","")
symboldefs = [ def_from_model(model,s) for s in symbols ]
function = evaluateTemplate.format(decl=sig,momenta=momentastring,defns=defString,
waves="\n ".join(waves),symbols='\n '.join(symboldefs),
couplings="\n ".join(localCouplings),
result=result[0],swap=sorder)
# special for transpose
if(FM or RS) :
h2=header
if(not RS) :
h2=header.replace("evaluate","evaluateN")
function=function.replace("evaluate(","evaluateN(")
headers=[]
newHeader=""
for ifunction in range(1,len(result)) :
waveNew=[]
momentastring=""
htemp = header.split(",")
irs=-1
isp=-1
# RS case
if(RS) :
# sort out the wavefunctions
for i in range(0,len(waves)) :
if(waves[i].find("Spinor")<0) :
waveNew.append(waves[i])
continue
if(waves[i].find("Bar")>0) :
waveNew.append(waves[i].replace("Bar","").replace("bar",""))
else :
waveNew.append(waves[i].replace("Spinor","SpinorBar").replace(" s"," sbar").replace("Rs","Rsbar"))
# sort out the momenta definitions
for i in range(0,len(momenta)) :
if(momenta[i][0] and momenta[i][1]!="") :
if(momenta[i][1].find("barW")>0) :
momentastring+=momenta[i][1].replace("barW","W")+"\n "
elif(momenta[i][1].find("sW")>0) :
momentastring+=momenta[i][1].replace("sW","sbarW")+"\n "
else :
momentastring+=momenta[i][1]+"\n "
# header string
for i in range(0,len(htemp)) :
if(htemp[i].find("RS")>0) :
if(htemp[i].find("Bar")>0) :
htemp[i]=htemp[i].replace("Bar","").replace("RsbarW","RsW")
else :
htemp[i]=htemp[i].replace("Spinor","SpinorBar").replace("RsW","RsbarW")
if(i>0) : irs=i
elif(htemp[i].find("Spinor")>0) :
if(htemp[i].find("Bar")>0) :
htemp[i]=htemp[i].replace("Bar","").replace("sbarW","sW")
else :
htemp[i]=htemp[i].replace("Spinor","SpinorBar").replace("sW","sbarW")
if(i>0) : isp=i
if(irs>0 and isp >0) :
htemp[irs],htemp[isp] = htemp[isp],htemp[irs]
# fermion case
else :
htemp2 = header.split(",")
# which fermions to exchange
if(len(fIndex)==2) :
isp = (fIndex[0],)
ibar = (fIndex[1],)
else :
if(ifunction==1) :
isp = (fIndex[2],)
ibar = (fIndex[3],)
elif(ifunction==2) :
isp = (fIndex[0],)
ibar = (fIndex[1],)
elif(ifunction==3) :
isp = (fIndex[0],fIndex[2])
ibar = (fIndex[1],fIndex[3])
# wavefunctions
for i in range(0,len(waves)) :
if(waves[i].find("Spinor")<0) :
waveNew.append(waves[i])
continue
if(waves[i].find("Bar")>0) :
found=False
for itest in range(0,len(ibar)) :
if(waves[i].find("sbarW%s"%ibar[itest])>=0) :
waveNew.append(waves[i].replace("Bar","").replace("bar",""))
found=True
break
if(not found) : waveNew.append(waves[i])
else :
found=False
for itest in range(0,len(isp)) :
if(waves[i].find("sW%s"%isp[itest])>=0) :
waveNew.append(waves[i].replace("Spinor","SpinorBar").replace(" s"," sbar"))
found=True
break
if(not found) : waveNew.append(waves[i])
# momenta definitions
for i in range(0,len(momenta)) :
if(momenta[i][0] and momenta[i][1]!="") :
if(momenta[i][1].find("barW")>0) :
found = False
for itest in range(0,len(ibar)) :
if(momenta[i][1].find("barW%s"%ibar[itest])>=0) :
momentastring+=momenta[i][1].replace("barW","W")+"\n "
found=True
break
if(not found) :
momentastring+=momenta[i][1]+"\n "
elif(momenta[i][1].find("sW")>0) :
found=False
for itest in range(0,len(isp)) :
if(momenta[i][1].find("sW%s"%isp[itest])>=0) :
momentastring+=momenta[i][1].replace("sW","sbarW")+"\n "
found=True
break
if(not found) :
momentastring+=momenta[i][1]+"\n "
else :
momentastring+=momenta[i][1]+"\n "
# header
for i in range(0,len(htemp)) :
if(htemp[i].find("Spinor")<0) : continue
if(htemp[i].find("Bar")>0) :
if(i==0) :
htemp[i] =htemp [i].replace("Bar","")
htemp2[i]=htemp2[i].replace("Bar","")
continue
for itest in range(0,len(ibar)) :
if(htemp[i].find("sbarW%s"%ibar[itest])>=0) :
htemp[i] =htemp [i].replace("Bar","").replace("sbarW","sW")
htemp2[i]=htemp2[i].replace("Bar","").replace("sbarW%s"%ibar[itest],"sW%s"%isp[itest])
break
else :
if(i==0) :
htemp [i]=htemp [i].replace("Spinor","SpinorBar")
htemp2[i]=htemp2[i].replace("Spinor","SpinorBar")
continue
for itest in range(0,len(isp)) :
if(htemp[i].find("sW%s"%isp[itest])>=0) :
htemp [i]=htemp [i].replace("Spinor","SpinorBar").replace("sW","sbarW")
htemp2[i]=htemp2[i].replace("Spinor","SpinorBar").replace("sW%s"%isp[itest],"sbarW%s"%ibar[itest])
break
# header for transposed function
hnew = ','.join(htemp)
hnew = hnew.replace("virtual ","").replace("=-GeV","")
if(not RS) :
theader = ','.join(htemp2)
theader = theader.replace("virtual ","").replace("=-GeV","")
if(len(result)==2) :
hnew =hnew .replace("evaluate","evaluateT")
theader=theader.replace("evaluate","evaluateT")
else :
hnew =hnew .replace("evaluate","evaluateT%s" % ifunction)
theader=theader.replace("evaluate","evaluateT%s" % ifunction)
if(iloc not in fIndex) :
theader = headerReplace(theader)
else :
theader = headerReplace(h2).replace("evaluateN","evaluateT")
headers.append(theader)
newHeader += hnew +";\n"
else :
newHeader += hnew
fnew = evaluateTemplate.format(decl=hnew,momenta=momentastring,defns=defString,
waves="\n ".join(waveNew),symbols='\n '.join(symboldefs),
couplings="\n ".join(localCouplings),
result=result[ifunction],swap=sorder)
function +="\n" + fnew
if(FM and not RS) :
if(len(result)==2) :
if(iloc!=fIndex[1]) :
fi=1
stype="sbar"
else :
fi=0
stype="s"
header = vTemplateT.format(header=header.replace("Energy2,","Energy2 q2,"),
normal=headerReplace(h2),
transpose=theader,type=stype,
iloc=fIndex[fi],id=vertex.particles[fIndex[fi]-1].pdg_code) \
+newHeader+h2.replace("virtual","")
else :
sorder = swapOrderFFFF(vertex,iloc,fIndex)
header = vTemplate4.format(header=header.replace("Energy2,","Energy2 q2,"),
iloc1=fIndex[1],iloc2=fIndex[3],swap=sorder,
id1=vertex.particles[fIndex[1]-1].pdg_code,
id2=vertex.particles[fIndex[3]-1].pdg_code,
cf=py2cpp(cf)[0],
res1=headerReplace(h2).replace("W",""),
res2=headers[0].replace("W",""),
res3=headers[1].replace("W",""),
res4=headers[2].replace("W",""))\
+newHeader+h2.replace("virtual","")
else :
header=header + ";\n" + newHeader
return (header,function)
evaluateMultiple = """\
{decl} {{
{code}
}}
"""
def multipleEvaluate(vertex,spin,defns) :
if(spin==1) :
name="scaW"
elif(spin==3) :
name="vW"
else :
print 'testing evaluate multiple problem',spin
quit()
if(len(defns)==0) : return ("","")
header = defns[0]
ccdefn = header.replace("=-GeV","").replace("virtual ","").replace("Energy2","Energy2 q2")
code=""
spins=vertex.lorentz[0].spins
iloc=1
waves=[]
for i in range(0,len(spins)) :
if(spins[i]==spin) :
waves.append("%s%s" %(name,i+1))
for i in range(0,len(spins)) :
if(spins[i]==spin) :
if(iloc==1) : el=""
else : el="else "
call = headerReplace(defns[iloc])
if(iloc!=1) :
call = call.replace(waves[0],waves[iloc-1])
pdgid = vertex.particles[i].pdg_code
code += " %sif(out->id()==%s) return %s;\n" % (el,pdgid,call)
iloc+=1
code+=" else assert(false);\n"
return (header,evaluateMultiple.format(decl=ccdefn,code=code))
diff --git a/Models/Feynrules/python/ufo2peg/vertices.py b/Models/Feynrules/python/ufo2peg/vertices.py
--- a/Models/Feynrules/python/ufo2peg/vertices.py
+++ b/Models/Feynrules/python/ufo2peg/vertices.py
@@ -1,847 +1,849 @@
import sys,pprint
from .helpers import CheckUnique,getTemplate,writeFile,coupling_orders,def_from_model
from .converter import py2cpp
from .collapse_vertices import collapse_vertices
from .check_lorentz import tensorCouplings,VVVordering,lorentzScalar,\
processTensorCouplings,scalarCouplings,processScalarCouplings,scalarVectorCouplings,\
processScalarVectorCouplings,vectorCouplings,processVectorCouplings,fermionCouplings,processFermionCouplings,\
RSCouplings
from .general_lorentz import convertLorentz,generateEvaluateFunction,multipleEvaluate
from .helpers import SkipThisVertex,extractAntiSymmetricIndices,isGoldstone
# prefactors for vertices
lfactors = {
'FFV' : '-complex(0,1)', # ok
'VVV' : 'complex(0,1)', # changed to fix ttbar
'VVVS' : 'complex(0,1)', # should be as VVV
'VVVV' : 'complex(0,1)',
'VVS' : '-complex(0,1)',
'VSS' : '-complex(0,1)', # changed to minus to fix dL ->x1 W- d
'SSS' : '-complex(0,1)', # ok
'VVSS' : '-complex(0,1)', # ok
'VVT' : 'complex(0,2)',
'VVVT' : '-complex(0,2)',
'SSSS' : '-complex(0,1)', # ok
'FFS' : '-complex(0,1)', # ok
'SST' : 'complex(0,2)',
'FFT' : '-complex(0,8)',
'FFVT' : '-complex(0,4)',
'RFS' : 'complex(0,1)',
'RFV' : 'complex(0,1)',
}
genericVertices=['FFFF','FFVV','FFSS','FFVS','VVVV','VVVT','FFVT','VVSS',
- 'RFVV','RFVS','RFSS']
+ 'RFVV','RFVS','RFSS','SSST','VVST','FFST']
skipped5Point=False
# template for the header for a vertex
VERTEXHEADER = """\
#include "ThePEG/Helicity/Vertex/{spindirectory}/{lorentztag}Vertex.h"
"""
GENERALVERTEXHEADER = """\
#include "ThePEG/Helicity/Vertex/Abstract{lorentztag}Vertex.h"
"""
# template for the implmentation for a vertex
VERTEXCLASS = getTemplate('Vertex_class')
GENERALVERTEXCLASS = getTemplate('GeneralVertex_class')
# template for the .cc file for vertices
VERTEX = getTemplate('Vertex.cc')
vertexline = """\
create Herwig::FRModel{classname} /Herwig/{modelname}/{classname}
insert {modelname}:ExtraVertices 0 /Herwig/{modelname}/{classname}
"""
def get_lorentztag(spin):
"""Produce a ThePEG spin tag for the given numeric FR spins."""
spins = { 1 : 'S', 2 : 'F', 3 : 'V', 4 : 'R', 5 : 'T', -1 : 'U' }
result=[]
for i in range(0,len(spin)) :
result.append((spins[spin[i]],i+1))
def spinsort(a,b):
"""Helper function for ThePEG's FVST spin tag ordering."""
(a1,a2) = a
(b1,b2) = b
if a1 == b1: return 0
for letter in 'URFVST':
if a1 == letter: return -1
if b1 == letter: return 1
result = sorted(result, cmp=spinsort)
order=[]
output=""
for i in range(0,len(result)) :
(a,b) = result[i]
order.append(b)
output+=a
return (output,order)
def unique_lorentztag(vertex):
"""Check and return the Lorentz tag of the vertex."""
unique = CheckUnique()
for l in vertex.lorentz:
(lorentztag,order) = get_lorentztag(l.spins)
unique( lorentztag )
lname = l.name[:len(lorentztag)]
if sorted(lorentztag) != sorted(lname):
raise Exception("Lorentztags: %s is not %s in %s"
% (lorentztag,lname,vertex))
return (lorentztag,order)
def colors(vertex) :
try:
unique = CheckUnique()
for pl in vertex.particles_list:
struct = [ p.color for p in pl ]
unique(struct)
except:
struct = [ p.color for p in vertex.particles ]
pos = colorpositions(struct)
L = len(struct)
return (L,pos)
def coloursort(a,b) :
if a == b: return 0
i1=int(a[4])
i2=int(b[4])
if(i1==i2) : return 0
elif(i1<i2) : return -1
else : return 1
def colorfactor(vertex,L,pos,lorentztag):
def match(patterns,color=vertex.color):
result = [ p == t
for p,t in zip(patterns,color) ]
return all(result)
label = None
l = lambda c: len(pos[c])
if l(1) == L:
label = ('1',)
if match(label): return ("SINGLET",('1.',))
elif l(3) == l(-3) == 1 and l(1) == L-2:
nums = [pos[3][0], pos[-3][0]]
label = ('Identity({0},{1})'.format(*sorted(nums)),)
if match(label): return ("DELTA",('1.',))
elif l(6) == l(-6) == 1 and l(1) == L-2:
nums = [pos[6][0], pos[-6][0]]
label = ('Identity({0},{1})'.format(*sorted(nums)),)
if match(label): return ("DELTA",('1.',))
elif l(6) == l(-6) == 2 and L==4:
sys.stderr.write(
'Warning: Unknown colour structure 6 6 6~ 6~ ( {ps} ) in {name}.\n'
.format(name=vertex.name, ps=' '.join(map(str,vertex.particles)))
)
raise SkipThisVertex()
elif l(8) == l(3) == l(-3) == 1 and l(1) == L-3:
label = ('T({g},{q},{qb})'.format(g=pos[8][0],q=pos[3][0],qb=pos[-3][0]),)
if match(label): return ("SU3TFUND",('1.',))
elif l(8) == l(6) == l(-6) == 1 and l(1) == L-3:
label = ('T6({g},{s},{sb})'.format(g=pos[8][0],s=pos[6][0],sb=pos[-6][0]),)
if match(label): return ("SU3T6",('1.',))
elif l(6) == 1 and l(-3) == 2 and L==3:
label = ('K6({s},{qb1},{qb2})'.format(s=pos[6][0],qb1=pos[-3][0],qb2=pos[-3][1]),)
if match(label): return ("K6",('1.',))
elif l(-6) == 1 and l(3) == 2 and L==3:
label = ('K6Bar({sb},{q1},{q2})'.format(sb=pos[-6][0],q1=pos[3][0],q2=pos[3][1]),)
if match(label): return ("K6",('1.',))
elif l(3) == L == 3:
colors=[]
for color in vertex.color :
order,sign = extractAntiSymmetricIndices(color,"Epsilon(")
colors.append("Epsilon(%s,%s,%s)" % (order[0],order[1],order[2]))
label = ('Epsilon(1,2,3)',)
if match(label,colors): return ("EPS",('1.',)) # TODO check factor!
elif l(-3) == L == 3:
colors=[]
for color in vertex.color :
order,sign = extractAntiSymmetricIndices(color,"EpsilonBar(")
colors.append("Epsilon(%s,%s,%s)" % (order[0],order[1],order[2]))
label = ('EpsilonBar(1,2,3)',)
if match(label): return ("EPS",('1.',)) # TODO check factor!
elif l(8) == L == 3:
colors=[]
for color in vertex.color :
order,sign = extractAntiSymmetricIndices(color,"f(")
colors.append("f(%s,%s,%s)" % (order[0],order[1],order[2]))
# if lorentz is FFV get extra minus sign
if lorentztag in ['FFV'] : sign *=-1
label = ('f(1,2,3)',)
if match(label,colors): return ("SU3F",('-complex(0,1.)*(%s)'%sign,))
elif l(8) == 3 and l(1)==1 and L == 4:
colors=[]
for color in vertex.color :
order,sign = extractAntiSymmetricIndices(color,"f(")
colors.append("f(%s,%s,%s)" % (order[0],order[1],order[2]))
if(pos[1][0]==1) :
label = ('f(2,3,4)',)
elif(pos[1][0]==2) :
label = ('f(1,3,4)',)
elif(pos[1][0]==3) :
label = ('f(1,2,4)',)
elif(pos[1][0]==4) :
label = ('f(1,2,3)',)
if match(label,colors): return ("SU3F",('-complex(0,1.)*(%s)'%sign,))
elif l(8) == L == 4:
colors=[]
for color in vertex.color :
f = color.split("*")
(o1,s1) = extractAntiSymmetricIndices(f[0],"f(")
(o2,s2) = extractAntiSymmetricIndices(f[1],"f(")
if(o2[0]<o1[0]) : o1,o2=o2,o1
colors.append("f(%s)*f(%s)" % (",".join(o1),",".join(o2)))
colors=sorted(colors,cmp=coloursort)
label = ('f(1,2,-1)*f(3,4,-1)',
'f(1,3,-1)*f(2,4,-1)',
'f(1,4,-1)*f(2,3,-1)')
nmatch=0
for c1 in label:
for c2 in colors :
if(c1==c2) : nmatch+=1
if(nmatch==2 and lorentztag=="VVSS") :
return ("SU3TTFUND",('1.','1.'))
elif(nmatch==3 and lorentztag=="VVVV") :
return ("SU3FF",('1.','1.','1.'))
elif l(8) == 2 and l(3) == l(-3) == 1 and L==4:
subs = {
'g1' : pos[8][0],
'g2' : pos[8][1],
'qq' : pos[3][0],
'qb' : pos[-3][0]
}
if(vertex.lorentz[0].spins.count(1)==2) :
label = ('T({g1},-1,{qb})*T({g2},{qq},-1)'.format(**subs),
'T({g1},{qq},-1)*T({g2},-1,{qb})'.format(**subs))
if match(label): return ("SU3TTFUNDS",('1.','1.'))
elif(vertex.lorentz[0].spins.count(2)==2) :
label = ('f({g1},{g2},-1)*T(-1,{qq},{qb})'.format(**subs),)
if match(label): return ("SU3TTFUNDD",('-complex(0.,1.)',))
label = ('f(-1,{g1},{g2})*T(-1,{qq},{qb})'.format(**subs),)
if match(label): return ("SU3TTFUNDD",('-complex(0.,1.)',))
elif l(8) == 2 and l(6) == l(-6) == 1 and L==4:
subs = {
'g1' : pos[8][0],
'g2' : pos[8][1],
'qq' : pos[6][0],
'qb' : pos[-6][0]
}
label = ('T6({g1},-1,{qb})*T6({g2},{qq},-1)'.format(**subs),
'T6({g1},{qq},-1)*T6({g2},-1,{qb})'.format(**subs))
if match(label): return ("SU3TT6",('1.','1.'))
elif l(8) == 2 and l(8)+l(1)==L :
subs = { 'g1' : pos[8][0], 'g2' : pos[8][1] }
label = ('Identity({g1},{g2})'.format(**subs),)
if match(label) : return ("DELTA",('1.',))
elif l(8) == 3 and l(1)==1 and L==4 :
colors=[]
for color in vertex.color :
order,sign = extractAntiSymmetricIndices(color,"f(")
colors.append("f(%s,%s,%s)" % (order[0],order[1],order[2]))
label = ('f(1,2,3)',)
if match(label,colors): return ("SU3F",('-complex(0.,1.)*(%s)'%sign,))
elif l(3)==2 and l(-3) == 2 and L==4 and lorentztag=="FFFF" :
labels=["Identity(1,2)*Identity(3,4)",
"Identity(1,4)*Identity(2,3)",
"T(-1,2,1)*T(-1,4,3)",
"T(-1,2,3)*T(-1,4,1)"]
cstruct=["SU3I12I34","SU3I14I23","SU3T21T43","SU3T23T41"]
oname=[]
ovalue=[]
for color in vertex.color :
for i in range(0,len(labels)) :
if labels[i]==color : break
if(i<len(labels)) :
oname.append(cstruct[i])
ovalue.append("1.")
else :
sys.stderr.write(
"Warning: Unknown colour structure {color} ( {ps} ) in {name} for FFFF vertex.\n"
.format(color = ' '.join(vertex.color), name = vertex.name,
ps = ' '.join(map(str,vertex.particles)))
)
raise SkipThisVertex()
return(oname,ovalue)
sys.stderr.write(
"Warning: Unknown colour structure {color} ( {ps} ) in {name}.\n"
.format(color = ' '.join(vertex.color), name = vertex.name,
ps = ' '.join(map(str,vertex.particles)))
)
raise SkipThisVertex()
def colorpositions(struct):
positions = {
1 : [],
3 : [],
-3 : [],
6 : [],
-6 : [],
8 : [],
}
for i,s in enumerate(struct,1):
positions[s].append(i)
return positions
def spindirectory(lt):
"""Return the spin directory name for a given Lorentz tag."""
if 'T' in lt:
spin_directory = 'Tensor'
elif 'S' in lt:
spin_directory = 'Scalar'
elif 'V' in lt:
spin_directory = 'Vector'
else:
raise Exception("Unknown Lorentz tag {lt}.".format(lt=lt))
return spin_directory
def write_vertex_file(subs):
'Write the .cc file for some vertices'
newname = '%s_Vertices_%03d.cc' % (subs['ModelName'],subs['vertexnumber'])
subs['newname'] = newname
writeFile( newname, VERTEX.substitute(subs) )
def checkGhostGoldstoneVertex(lorentztag,vertex) :
'check if vertex has ghosts or goldstones'
# remove vertices involving ghost fields
if 'U' in lorentztag:
return True
# remove vertices involving goldstones
for p in vertex.particles:
if(isGoldstone(p)):
return True
return False
def calculatePrefactor(lf,cf) :
prefactor = '(%s) * (%s)' % (lf,cf)
return prefactor
def couplingValue(coupling) :
if type(coupling) is not list:
value = coupling.value
else:
value = "("
for coup in coupling :
value += '+(%s)' % coup.value
value +=")"
return value
def epsilonSign(vertex,couplingptrs,append) :
EPSSIGN = """\
double sign = {epssign};
if((p1->id()=={id1} && p2->id()=={id3} && p3->id()=={id2}) ||
(p1->id()=={id2} && p2->id()=={id1} && p3->id()=={id3}) ||
(p1->id()=={id3} && p2->id()=={id2} && p3->id()=={id1})) {{
sign *= -1.;
}}
norm(norm()*sign);
"""
if(not "p1" in couplingptrs[0]) :
couplingptrs[0] += ' p1'
if(not "p2" in couplingptrs[1]) :
couplingptrs[1] += ' p2'
if(not "p3" in couplingptrs[2]) :
couplingptrs[2] += ' p3'
if("Bar" not in vertex.color[0]) :
order,sign = extractAntiSymmetricIndices(vertex.color[0],"Epsilon(")
else :
order,sign = extractAntiSymmetricIndices(vertex.color[0],"EpsilonBar(")
subs = {"id1" : vertex.particles[int(order[0])-1].pdg_code,
"id2" : vertex.particles[int(order[1])-1].pdg_code,
"id3" : vertex.particles[int(order[2])-1].pdg_code,
"epssign" : sign }
append+=EPSSIGN.format(**subs)
return couplingptrs,append
class VertexConverter:
'Convert the vertices in a FR model to extract the information ThePEG needs.'
def __init__(self,model,parmsubs,defns) :
'Initialize the parameters'
self.verbose=False
self.vertex_skipped=False
self.ignore_skipped=False
self.model=model
self.all_vertices= []
self.vertex_names = {}
self.modelname=""
self.no_generic_loop_vertices = False
self.parmsubs = parmsubs
self.couplingDefns = defns
def readArgs(self,args) :
'Extract the relevant command line arguments'
self.ignore_skipped = args.ignore_skipped
self.verbose = args.verbose
self.modelname = args.name
self.no_generic_loop_vertices = args.no_generic_loop_vertices
self.include_generic = args.include_generic
def should_print(self) :
'Check if we should output the results'
return not self.vertex_skipped or self.ignore_skipped
def convert(self) :
'Convert the vertices'
if(self.verbose) :
print 'verbose mode on: printing all vertices'
print '-'*60
labels = ('vertex', 'particles', 'Lorentz', 'C_L', 'C_R', 'norm')
pprint.pprint(labels)
# extract the vertices
self.all_vertices = self.model.all_vertices
# convert the vertices
vertexclasses, vertexheaders = [], set()
ifile=1
icount=0
for vertexnumber,vertex in enumerate(self.all_vertices,1) :
# process the vertex
(skip,vertexClass,vertexHeader) = \
self.processVertex(vertexnumber,vertex)
# check it can be handled
if(skip) : continue
# add to the list
icount +=1
vertexclasses.append(vertexClass)
vertexheaders.add(vertexHeader)
WRAP = 25
if icount % WRAP == 0 or vertexHeader.find("Abstract")>=0:
write_vertex_file({'vertexnumber' : ifile,
'vertexclasses' : '\n'.join(vertexclasses),
'vertexheaders' : ''.join(vertexheaders),
'ModelName' : self.modelname})
vertexclasses = []
vertexheaders = set()
icount=0
ifile+=1
# exit if there's vertices we can't handle
if not self.should_print():
sys.stderr.write(
"""
Error: The conversion was unsuccessful, some vertices could not be
generated. If you think the missing vertices are not important
and want to go ahead anyway, use --ignore-skipped.
Herwig may not give correct results, though.
"""
)
sys.exit(1)
# if still stuff to output it do it
if vertexclasses:
write_vertex_file({'vertexnumber' : ifile + 1,
'vertexclasses' : '\n'.join(vertexclasses),
'vertexheaders' : ''.join(vertexheaders),
'ModelName' : self.modelname})
print '='*60
def setCouplingPtrs(self,lorentztag,qcd,append,prepend) :
couplingptrs = [',tcPDPtr']*len(lorentztag)
if lorentztag == 'VSS':
couplingptrs[1] += ' p2'
elif lorentztag == 'FFV':
couplingptrs[0] += ' p1'
elif (lorentztag == 'VVV' or lorentztag == 'VVVS' or
lorentztag == "SSS" or lorentztag == "VVVT" ) \
and (append or prepend ) :
couplingptrs[0] += ' p1'
couplingptrs[1] += ' p2'
couplingptrs[2] += ' p3'
elif (lorentztag == 'VVVV' and qcd < 2) or\
(lorentztag == "SSSS" and prepend ):
couplingptrs[0] += ' p1'
couplingptrs[1] += ' p2'
couplingptrs[2] += ' p3'
couplingptrs[3] += ' p4'
return couplingptrs
def processVertex(self,vertexnumber,vertex) :
global skipped5Point
# get the Lorentz tag for the vertex
lorentztag,order = unique_lorentztag(vertex)
# check if we should skip the vertex
vertex.herwig_skip_vertex = checkGhostGoldstoneVertex(lorentztag,vertex)
# check the order of the vertex and skip 5 points
if(len(lorentztag)>=5) :
vertex.herwig_skip_vertex = True
if(not skipped5Point) :
skipped5Point = True
print "Skipping 5 point vertices which aren\'t used in Herwig7"
if(vertex.herwig_skip_vertex) :
return (True,"","")
# check if we support this at all
if( lorentztag not in lfactors and
lorentztag not in genericVertices) :
msg = 'Warning: Lorentz structure {tag} ( {ps} ) in {name} ' \
'is not supported.\n'.format(tag=lorentztag, name=vertex.name,
ps=' '.join(map(str,vertex.particles)))
sys.stderr.write(msg)
vertex.herwig_skip_vertex = True
self.vertex_skipped=True
return (True,"","")
# get the factor for the vertex
generic = False
try:
lf = lfactors[lorentztag]
- if "T" in lorentztag : raise KeyError
+ #if lorentztag =="FFVT" : raise KeyError
+ #if "T" in lorentztag and "F" not in lorentztag : raise KeyError
+ #if "T" in lorentztag : raise KeyError
except KeyError:
if(not self.include_generic) :
msg = 'Warning: Lorentz structure {tag} ( {ps} ) in {name} ' \
'is not supported.\n'.format(tag=lorentztag, name=vertex.name,
ps=' '.join(map(str,vertex.particles)))
sys.stderr.write(msg)
vertex.herwig_skip_vertex = True
self.vertex_skipped=True
return (True,"","")
else :
lf=1.
generic=True
# get the ids of the particles at the vertex
plistarray = [ ','.join([ str(vertex.particles[o-1].pdg_code) for o in order ]) ]
# parse the colour structure for the vertex
try:
L,pos = colors(vertex)
cs,cf = colorfactor(vertex,L,pos,lorentztag)
except SkipThisVertex:
msg = 'Warning: Color structure for vertex ( {ps} ) in {name} ' \
'is not supported.\n'.format(tag=lorentztag, name=vertex.name,
ps=' '.join(map(str,vertex.particles)))
sys.stderr.write(msg)
vertex.herwig_skip_vertex = True
self.vertex_skipped=True
return (True,"","")
### classname
classname = 'V_%s' % vertex.name
if(not generic) :
try :
return self.extractGeneric(vertex,order,lorentztag,classname,plistarray,pos,lf,cf,cs)
except SkipThisVertex:
if(not self.include_generic) :
msg = 'Warning: Lorentz structure {tag} ( {ps} ) in {name} ' \
'is not supported, may have a non-perturbative form.\n'.format(tag=lorentztag, name=vertex.name,
ps=' '.join(map(str,vertex.particles)))
sys.stderr.write(msg)
vertex.herwig_skip_vertex = True
self.vertex_skipped=True
return (True,"","")
else :
try :
return self.extractGeneral(vertex,order,lorentztag,classname,plistarray,pos,cf,cs)
except SkipThisVertex:
msg = 'Warning: Lorentz structure {tag} ( {ps} ) in {name} ' \
'is not supported, may have a non-perturbative form.\n'.format(tag=lorentztag, name=vertex.name,
ps=' '.join(map(str,vertex.particles)))
sys.stderr.write(msg)
vertex.herwig_skip_vertex = True
self.vertex_skipped=True
return (True,"","")
else :
try :
return self.extractGeneral(vertex,order,lorentztag,classname,plistarray,pos,cf,cs)
except SkipThisVertex:
msg = 'Warning: Lorentz structure {tag} ( {ps} ) in {name} ' \
'is not supported, may have a non-perturbative form.\n'.format(tag=lorentztag, name=vertex.name,
ps=' '.join(map(str,vertex.particles)))
sys.stderr.write(msg)
vertex.herwig_skip_vertex = True
self.vertex_skipped=True
return (True,"","")
def extractGeneric(self,vertex,order,lorentztag,classname,plistarray,pos,lf,cf,cs) :
classes=""
headers=""
# identify the maximum colour flow and orders of the couplings
maxColour=0
couplingOrders=[]
self.vertex_names[vertex.name] = [classname]
for (color_idx,lorentz_idx),coupling in vertex.couplings.iteritems():
maxColour=max(maxColour,color_idx)
orders = coupling_orders(vertex, coupling, self.couplingDefns)
if(orders not in couplingOrders) : couplingOrders.append(orders)
# loop the order of the couplings
iorder = 0
for corder in couplingOrders :
iorder +=1
cname=classname
if(iorder!=1) :
cname= "%s_%s" % (classname,iorder)
self.vertex_names[vertex.name].append(cname)
header = ""
prepend=""
append=""
all_couplings=[]
for ix in range(0,maxColour+1) :
all_couplings.append([])
# loop over the colour structures
for colour in range(0,maxColour+1) :
for (color_idx,lorentz_idx),coupling in vertex.couplings.iteritems() :
# check colour structure and coupling order
if(color_idx!=colour) : continue
if(coupling_orders(vertex, coupling, self.couplingDefns)!=corder) : continue
# get the prefactor for the lorentz structure
L = vertex.lorentz[lorentz_idx]
prefactors = calculatePrefactor(lf,cf[color_idx])
# calculate the value of the coupling
value = couplingValue(coupling)
# handling of the different types of couplings
if lorentztag in ['FFS','FFV']:
all_couplings[color_idx] = fermionCouplings(value,prefactors,L,all_couplings[color_idx],order)
elif 'T' in lorentztag :
append, all_couplings[color_idx] = tensorCouplings(vertex,value,prefactors,L,lorentztag,pos,
all_couplings[color_idx],order)
elif 'R' in lorentztag :
all_couplings[color_idx] = RSCouplings(value,prefactors,L,all_couplings[color_idx],order)
elif lorentztag == 'VVS' or lorentztag == "VVSS" or lorentztag == "VSS" :
all_couplings[color_idx] = scalarVectorCouplings(value,prefactors,L,lorentztag,
all_couplings[color_idx],order)
elif lorentztag == "SSS" or lorentztag == "SSSS" :
prepend, header, all_couplings[color_idx] = scalarCouplings(vertex,value,prefactors,L,lorentztag,
all_couplings[color_idx],prepend,header)
elif "VVV" in lorentztag :
all_couplings[color_idx],append = vectorCouplings(vertex,value,prefactors,L,lorentztag,pos,
all_couplings[color_idx],append,corder["QCD"],order)
else:
raise SkipThisVertex()
# set the coupling ptrs in the setCoupling call
couplingptrs = self.setCouplingPtrs(lorentztag,corder["QCD"],append != '',prepend != '')
# final processing of the couplings
symbols = set()
if(lorentztag in ['FFS','FFV']) :
(normcontent,leftcontent,rightcontent,append) = processFermionCouplings(lorentztag,vertex,
self.model,self.parmsubs,
all_couplings,order)
elif('T' in lorentztag) :
(leftcontent,rightcontent,normcontent) = processTensorCouplings(lorentztag,vertex,self.model,
self.parmsubs,all_couplings,order)
elif(lorentztag=="SSS" or lorentztag=="SSSS") :
normcontent = processScalarCouplings(self.model,self.parmsubs,all_couplings)
elif(lorentztag=="VVS" or lorentztag =="VVSS" or lorentztag=="VSS") :
normcontent,append,lorentztag,header,sym = processScalarVectorCouplings(lorentztag,vertex,
self.model,self.parmsubs,
all_couplings,header,order)
symbols |=sym
elif("VVV" in lorentztag) :
normcontent,append,header =\
processVectorCouplings(lorentztag,vertex,self.model,self.parmsubs,all_couplings,append,header)
else :
SkipThisVertex()
### do we need left/right?
if 'FF' in lorentztag and lorentztag != "FFT":
#leftcalc = aStoStrongCoup(py2cpp(leftcontent)[0], paramstoreplace_, paramstoreplace_expressions_)
#rightcalc = aStoStrongCoup(py2cpp(rightcontent)[0], paramstoreplace_, paramstoreplace_expressions_)
leftcalc, sym = py2cpp(leftcontent)
symbols |= sym
rightcalc, sym = py2cpp(rightcontent)
symbols |= sym
left = 'left(' + leftcalc + ');'
right = 'right(' + rightcalc + ');'
else:
left = ''
right = ''
leftcalc = ''
rightcalc = ''
#normcalc = aStoStrongCoup(py2cpp(normcontent)[0], paramstoreplace_, paramstoreplace_expressions_)
normcalc, sym = py2cpp(normcontent)
symbols |= sym
# UFO is GeV by default
if lorentztag in ['VVS','SSS']:
normcalc = 'Complex((%s) * GeV / UnitRemoval::E)' % normcalc
elif lorentztag in ['GeneralVVS']:
normcalc = 'Complex(-(%s) * UnitRemoval::E / GeV )' % normcalc
elif lorentztag in ['FFT','VVT', 'SST', 'FFVT', 'VVVT' , 'VVVS' ]:
normcalc = 'Complex((%s) / GeV * UnitRemoval::E)' % normcalc
norm = 'norm(' + normcalc + ');'
# finally special handling for eps tensors
if(len(vertex.color)==1 and vertex.color[0].find("Epsilon")>=0) :
couplingptrs, append = epsilonSign(vertex,couplingptrs,append)
# define unkown symbols from the model
symboldefs = [ def_from_model(self.model,s) for s in symbols ]
couplingOrder=""
for coupName,coupVal in corder.iteritems() :
couplingOrder+=" orderInCoupling(CouplingType::%s,%s);\n" %(coupName,coupVal)
### assemble dictionary and fill template
subs = { 'lorentztag' : lorentztag, # ok
'classname' : cname, # ok
'symbolrefs' : '\n '.join(symboldefs),
'left' : left, # doesn't always exist in base
'right' : right, # doesn't always exist in base
'norm' : norm, # needs norm, too
'addToPlist' : '\n'.join([ 'addToList(%s);'%s for s in plistarray]),
'parameters' : '',
'couplingOrders' : couplingOrder,
'colourStructure' : cs,
'couplingptrs' : ''.join(couplingptrs),
'spindirectory' : spindirectory(lorentztag),
'ModelName' : self.modelname,
'prepend' : prepend,
'append' : append,
'header' : header
} # ok
# print info if required
if self.verbose:
print '-'*60
pprint.pprint(( classname, plistarray, leftcalc, rightcalc, normcalc ))
headers+=VERTEXHEADER.format(**subs)
classes+=VERTEXCLASS.substitute(subs)
return (False,classes,headers)
def extractGeneral(self,vertex,order,lorentztag,classname,plistarray,pos,cf,cs) :
eps=False
classes=""
headers=""
# check the colour flows, three cases supported either 1 flow or 3 in gggg
# or multiple wierd ones in FFFF
cidx=-1
gluon4point = (len(pos[8])==4 and vertex.lorentz[0].spins.count(3)==4)
FFFF = (len(pos[3])==2 and len(pos[-3])==2 and vertex.lorentz[0].spins.count(2)==4)
couplingOrders=[]
colours={}
for (color_idx,lorentz_idx),coupling in vertex.couplings.iteritems() :
orders = coupling_orders(vertex, coupling, self.couplingDefns)
if(orders not in couplingOrders) : couplingOrders.append(orders)
if(gluon4point) :
color = vertex.color[color_idx]
f = color.split("*")
(o1,s1) = extractAntiSymmetricIndices(f[0],"f(")
(o2,s2) = extractAntiSymmetricIndices(f[1],"f(")
if(o2[0]<o1[0]) : o1,o2=o2,o1
color = "f(%s)*f(%s)" % (",".join(o1),",".join(o2))
label = 'f(1,3,-1)*f(2,4,-1)'
if(label==color) :
cidx=color_idx
colours[cidx] = (cs,cf[cidx])
elif (FFFF) :
colours[color_idx] = (cs[color_idx],cf[color_idx])
else :
cidx=color_idx
if(color_idx!=0) :
vertex.herwig_skip_vertex = True
self.vertex_skipped=True
msg = 'Warning: General spin structure code currently only '\
'supports 1 colour structure for {tag} ( {ps} ) in {name}\n'.format(tag=lorentztag, name=vertex.name,
ps=' '.join(map(str,vertex.particles)))
sys.stderr.write(msg)
return (True,"","")
if(isinstance(cs,basestring)) :
colours[cidx] = (cs,cf[cidx])
else :
vertex.herwig_skip_vertex = True
self.vertex_skipped=True
msg = 'Warning: General spin structure code currently only '\
'supports 1 colour structure for {tag} ( {ps} ) in {name}\n'.format(tag=lorentztag, name=vertex.name,
ps=' '.join(map(str,vertex.particles)))
sys.stderr.write(msg)
return (True,"","")
if(len(colours)==0) :
msg = 'Warning: General spin structure code currently only '\
'supports 1 colour structure for {tag} ( {ps} ) in {name}\n'.format(tag=lorentztag, name=vertex.name,
ps=' '.join(map(str,vertex.particles)))
sys.stderr.write(msg)
vertex.herwig_skip_vertex = True
self.vertex_skipped=True
return (True,"","")
# loop over the different orders in the couplings
# and colour structures
iorder=0
self.vertex_names[vertex.name]=[classname]
for corder in couplingOrders :
for (cidx,(cstruct,cfactor)) in colours.iteritems() :
iorder +=1
cname=classname
if(iorder!=1) :
cname= "%s_%s" % (classname,iorder)
self.vertex_names[vertex.name].append(cname)
defns=[]
vertexEval=[]
values=[]
imax = len(vertex.particles)+1
if lorentztag in genericVertices :
imax=1
for (color_idx,lorentz_idx),coupling in vertex.couplings.iteritems() :
# only the colour structre and coupling order we want
if(color_idx != cidx) : continue
if(coupling_orders(vertex, coupling, self.couplingDefns)!=corder) : continue
# calculate the value of the coupling
values.append(couplingValue(coupling))
# now to convert the spin structures
for i in range(0,imax) :
if(len(defns)<i+1) :
defns.append({})
vertexEval.append([])
eps |= convertLorentz(vertex.lorentz[lorentz_idx],lorentztag,order,vertex,
i,defns[i],vertexEval[i])
# we can now generate the evaluate member functions
header=""
impls=""
spins=vertex.lorentz[0].spins
mult={}
for i in range(1,6) :
if( spins.count(i)>1 and i!=2) : mult[i] = []
for i in range(0,imax) :
(evalHeader,evalCC) = generateEvaluateFunction(self.model,vertex,i,values,defns[i],vertexEval[i],cfactor,order)
if(i!=0 and spins[i-1] in mult) :
if(len(mult[spins[i-1]])==0) : mult[spins[i-1]].append(evalHeader)
evalHeader=evalHeader.replace("evaluate(","evaluate%s(" % i)
evalCC =evalCC .replace("evaluate(","evaluate%s(" % i)
mult[spins[i-1]].append(evalHeader)
header+=" "+evalHeader+";\n"
impls+=evalCC
# combine the multiple defn if needed
for (key,val) in mult.iteritems() :
(evalHeader,evalCC) = multipleEvaluate(vertex,key,val)
if(evalHeader!="") : header += " "+evalHeader+";\n"
if(evalCC!="") : impls += evalCC
impls=impls.replace("evaluate", "FRModel%s::evaluate" % cname)
couplingOrder=""
for coupName,coupVal in corder.iteritems() :
couplingOrder+=" orderInCoupling(CouplingType::%s,%s);\n" %(coupName,coupVal)
### assemble dictionary and fill template
subs = { 'lorentztag' : lorentztag,
'classname' : cname,
'addToPlist' : '\n'.join([ 'addToList(%s);'%s for s in plistarray]),
'ModelName' : self.modelname,
'couplingOrders' : couplingOrder,
'colourStructure' : cstruct,
'evaldefs' : header,
'evalimpls' : impls}
newHeader = GENERALVERTEXHEADER.format(**subs)
if(eps) : newHeader +="#include \"ThePEG/Helicity/epsilon.h\"\n"
headers+=newHeader
classes+=GENERALVERTEXCLASS.substitute(subs)
return (False,classes,headers)
def get_vertices(self,libname):
vlist = ['library %s\n' % libname]
for v in self.all_vertices:
if v.herwig_skip_vertex: continue
for name in self.vertex_names[v.name] :
vlist.append( vertexline.format(modelname=self.modelname, classname=name) )
if( not self.no_generic_loop_vertices) :
vlist.append('insert {modelname}:ExtraVertices 0 /Herwig/{modelname}/V_GenericHPP\n'.format(modelname=self.modelname) )
vlist.append('insert {modelname}:ExtraVertices 0 /Herwig/{modelname}/V_GenericHGG\n'.format(modelname=self.modelname) )
return ''.join(vlist)