**Next message:**Mario Schenberg: "Bug in Oneloop function (?)"**Previous message:**Lingxiao Xu: "Re: Problems of two QCD processes calculating by FeynCalc and bugs of Contract?"**In reply to:**Lingxiao Xu: "Re: Problems of two QCD processes calculating by FeynCalc and bugs of Contract?"**Messages sorted by:**[ date ] [ thread ] [ subject ] [ author ]**Mail actions:**[ respond to this message ] [ mail a new topic ]

Hi,

glad that you figured it out yourself. For the sake of other people

reading this mailing list that might have similar concerns, I took the

liberty to answer your previous questions.

* > SUNSimplify[SUNTrace[SUNT[i, j, i, j]], Explicit -> True] just gives
*

* > -2/3; while SUNSimplify[SUNT[i, j, i, j], Explicit -> True] gives
*

* > -2/9.why these two differ by a factor "3"?
*

The output is different, because in the first case you are computing

the trace of T^i T^j T^i T^j, while in the second case you just

simplify T^i T^j T^i T^j. In the former case you get a number,

while in the latter case you get a number *times* the 3x3 unit matrix.

If you apply SUNTrace to SUNSimplify[SUNT[i, j, i, j], you will get

-(2/9)*3 = -2/3 where 3 comes from the trace of the unit matrix. Thus,

SUNSimplify[SUNTrace[SUNT[i, j, i, j]], SUNNToCACF -> False] and

SUNTrace[SUNSimplify[SUNT[i, j, i, j], SUNNToCACF -> False]] give you

the same result as it should be.

* > As for the process(q,qbar->q,qbar),I guess we can just get the
*

* > correct result by fixing the relative minus sign between two
*

* > diagrams. It seems that,in my code, SUNSimplify can also make the
*

* > color factor right, at least giving the right result.
*

* > So DOES IT RIGHT OR WRONG?
*

It is wrong to ignore obvious mistakes only because the result looks

fine. SUNSimplify always expects that you apply it on a chain of T

matrices like T^A_ij T^B_jk T^C_kl. If you have something like T^A_ij

T^B_kl T^C_mn instead, you will obviously get a wrong result.

You can persuade yourself by looking at the q_i q_j -> q_i q_j

process. There you have the same issue and you will not get the correct

prefactor, unless you use that the amplitude is proportional to T^A_ik

T^A_jk and not to T^A.T^A.

* > WHAT IF THERE ARE MORE TERMS CARRYING COLOR FACTORS, SHOULD WE JUST
*

* > EVALUATE IT BY HAND NOW OR WE CAN MAKE IT SIMPLER?
*

If you have n external quarks that can carry different colors, your

amplitude will be proportional to n different fundamental indices. As I

previously stated, Feyncalc doesn't have bulit-in support for SUNT

matrices with explicit fundamental indices yet. However, since Feyncalc

runs on top of Mathematica it is not really difficult to make it handle

such objects properly in a given computation. Let me show how this can

be done.

The idea is to introduce a function SUNTE [ {x}, i,j] which corresponds

to T^x_ij, where x is the adjoint and i,j are fundamental color indices.

Since SUNTE defines a matrix element, it commutes with all other objects

and we don't need to care about DOT or commutators. Then you need to

define a replacement rule that can "sew" our SUNTE matrices together

when they have a common index, i.e. SUNTE [ {x}, i,j] SUNTE [ {y}, i,k]

will become SUNTE [ {x,y}, i,k]. If we want to obtain the complex

conjugate, we need to swap the fundamental indices. Finally, if both

fundamental indices are the same, then we have a trace, since SUNTE [

{x,y,z}, i,i] is nothing else than SUNTrace[SUNT[ x,y,z]. If you input

the amplitudes by hand, then you clearly need to make sure that you use

the correct indices everywhere. But the rest will be evaluated

automatically! Here is how one would modify your q qbar -> q qbar code

to use this approach.

----------------------------------------------------------------------

<< HighEnergyPhysics`FeynCalc`

SUNTESimplify[ex_] :=

ex //. {SUNTE[{x__}, i_, j_] SUNTE[{y__}, j_, k_] :>

SUNTE[{x, y}, i, k],

SUNTE[{x__}, i_, i_] :>

SUNSimplify[SUNTrace[SUNT[x]], Explicit -> True,

SUNNToCACF -> False]};

SetMandelstam[s, t, u, p1, p2, -p3, -p4, 0, 0, 0, 0];

ScPr[p_, m_] := -I/(ScalarProduct[p] - m^2) // ExpandScalarProduct;

ftrace = {DiracTrace -> Tr2, D -> 4};

SUNN = 3;

SetOptions[SUNSimplify, SUNNToCACF -> False];

qav = 6;

f1 = (SpinorVBar[p2, 0].QGV[\[Alpha], a].SpinorU[p1, 0] ScPr[p1 + p2,

0] SpinorUBar[p3, 0].QGV[\[Alpha], b].SpinorV[p4, 0] //

Explicit) /. {SUNT[SUNIndex[a]] -> SUNTE[{a}, i, j],

SUNT[SUNIndex[b]] -> SUNTE[{a}, l, k]};

f2 = -(SpinorUBar[p3, 0].QGV[\[Alpha], a].SpinorU[p1, 0] ScPr[p1 - p3,

0] SpinorVBar[p2, 0].QGV[\[Alpha], b].SpinorV[p4, 0] //

Explicit) /. {SUNT[SUNIndex[a]] -> SUNTE[{a}, i, k],

SUNT[SUNIndex[b]] -> SUNTE[{a}, l, j]};

f1s = (SpinorUBar[p1, 0].QGV[\[Beta], a].SpinorV[p2,

0] (-ScPr[p1 + p2, 0]) SpinorVBar[p4, 0].QGV[\[Beta],

b].SpinorU[p3, 0] // Explicit) /. {SUNT[SUNIndex[a]] ->

SUNTE[{b}, j, i], SUNT[SUNIndex[b]] -> SUNTE[{b}, k, l]};

f2s = -(SpinorUBar[p1, 0].QGV[\[Beta], a].SpinorU[p3,

0] (-ScPr[p1 - p3, 0]) SpinorVBar[p4, 0].QGV[\[Beta],

b].SpinorV[p2, 0] // Explicit) /. {SUNT[SUNIndex[a]] ->

SUNTE[{b}, k, i], SUNT[SUNIndex[b]] -> SUNTE[{b}, j, l]};

f = f1 + f2;

fstar = f1s + f2s;

Msq = (1/(qav^2 Gstrong^4)) ((FermionSpinSum[f fstar] // Explicit //

Expand) /. ftrace) // Contract // SUNTESimplify //

SUNSimplify // Expand

standard = 4/9 ((s^2 + u^2)/t^2 + (u^2 + t^2)/s^2 - 2/3 u^2/(s t));

TrickMandelstam[Msq - standard, {s, t, u, 0}]

----------------------------------------------------------------------

You can automatize this even further if you use FeynArts to generate

your amplitudes. FeynArts always writes color matrices with explicit

fundamental indices, such that it is very simple to convert it to our

SUNTE. Here's an example of computing qg->qg that works with the current

development snapshot. You can also modify it to run with Feyncalc 8.2,

but there you don't have the new function for automatic renaming of

dummy indices , that I added only recently. Note that I also defined a

function InsertPolSum to do polarization

sums for gluons without bothering about Lorentz indices

----------------------------------------------------------------------

$LoadPhi = $LoadTARCER = False;

$LoadFeynArts = True;

<< HighEnergyPhysics`FeynCalc`

$FAVerbose = 0;

top = CreateTopologies[0, 2 -> 2];

diags =

InsertFields[top, {F[3, {1}], V[5]} -> {F[3, {1}], V[5]},

InsertionLevel -> {Classes},

Model -> "SMQCD",

ExcludeParticles -> {V[1], S[1], S[2], V[2]}];

Paint[diags, ColumnsXRows -> {3, 1}, Numbering -> None];

amps = Map[ReplaceAll[#, FeynAmp[_, _, amp_, ___] :> amp] &,

Apply[List,

FCPrepareFAAmp[CreateFeynAmp[diags,

Truncated -> False,

PreFactor -> 1]]]] //. {(a1__ DiracGamma[6] a2__ +

a1__ DiracGamma[7] a2__) :> a1 a2,

NonCommutative[x___] -> x,

FermionChain -> DOT, DiracSpinor -> Spinor,

FourMomentum[Incoming, 1] -> p1,

FourMomentum[Incoming, 2] -> q1,

FourMomentum[Outgoing, 1] -> p2,

FourMomentum[Outgoing, 2] -> q2,

Index[Lorentz, x_] :>

LorentzIndex[ToExpression["Lor" <> ToString[x]]],

Index[Gluon, x_] :>

SUNIndex[ToExpression["Glu" <> ToString[x]]],

SumOver[__] :> 1,

SUNT[a_, i_, j_] :>

SUNTE[{SUNIndex[a]}, SUNIndex[i], SUNIndex[j]], MU -> MQ,

GaugeXi[g] -> GaugeXi,

Conjugate[PolarizationVector][_, x_, y_] :>

Conjugate[PolarizationVector[x, y, Transversality -> True]],

PolarizationVector[_, x_, y_] :>

PolarizationVector[x, y, Transversality -> True],

Index[Colour, x_] :> ToExpression["Col" <> ToString[x]]};

SUNTESimplify[ex_] :=

ex //. {SUNTE[{x__}, i_, j_] SUNTE[{y__}, j_, k_] :>

SUNTE[{x, y}, i, k],

SUNTE[{x__}, i_, i_] :>

SUNSimplify[SUNTrace[SUNT[x]], Explicit -> True,

SUNNToCACF -> False]};

InsertPolSum[ex_, mom_, auxmom_] :=

ex //. {Pair[LorentzIndex[x_],

Momentum[Polarization[mom, I, Transversality -> True]]] Pair[

LorentzIndex[y_],

Momentum[Polarization[mom, -I, Transversality -> True]]] :>

PolarizationSum[x, y, mom, auxmom]};

SetMandelstam[s, t, u, p1, q1, -p2, -q2, 0, 0, 0, 0];

ampsMassless = amps // ReplaceAll[#, MQ -> 0] &;

sqAmpMassless = (1/(6*16)) Total[

ampsMassless] (Total[ampsMassless] //

ComplexConjugate // FCRenameDummyIndices //

ReplaceAll[#,

SUNTE[{x__}, i_, j_] :> SUNTE[{x}, j, i]] &) //

FermionSpinSum // InsertPolSum[#, q1, p1] & //

InsertPolSum[#, q2, p2] & // Contract //

PropagatorDenominatorExplicit //

ReplaceAll[#,

DiracTrace[x_] :>

DiracTrace[x, DiracTraceEvaluate -> True]] & //

SUNTESimplify //

SUNSimplify[#, Explicit -> True, SUNNToCACF -> False] & //

ReplaceAll[#, {SUNN -> 3, MQ -> 0}] & // Simplify //

TrickMandelstam[#, {s, t, u, 0}] & // Expand

standard = ((s^2 + u^2)/t^2 - (4/9) (s^2 + u^2)/(s u)) Gstrong^4;

TrickMandelstam[sqAmpMassless - standard, {s, t, u, 0}]

----------------------------------------------------------------------

Cheers,

Vladyslav

On 06/11/14 17:08, Lingxiao Xu wrote:

*> Hi,
*

*> I'm very sorry to made a few mistakes in my previous message. As for the process on quark gluon scattering, there is a typo when defining the scalar propagator, ScalarProduct[p] just shouldn't be squared. I can get the correct answer without using SUNTrace in the last few steps, SUNSimplify is enough at that stage. I just did a few more related QCD processes, and I think I have been much more familiar with FeynCalc now. That is fine.
*

*>
*

*> Cheers!
*

*>
*

*> Lingxiao Xu
*

*>
*

**Next message:**Mario Schenberg: "Bug in Oneloop function (?)"**Previous message:**Lingxiao Xu: "Re: Problems of two QCD processes calculating by FeynCalc and bugs of Contract?"**In reply to:**Lingxiao Xu: "Re: Problems of two QCD processes calculating by FeynCalc and bugs of Contract?"**Messages sorted by:**[ date ] [ thread ] [ subject ] [ author ]**Mail actions:**[ respond to this message ] [ mail a new topic ]

*
This archive was generated by hypermail 2b29
: 12/15/18-05:20:01 PM Z CET
*