← Back to branch summary

~maddevelopers/mg5amcnlo/WWW5_caching

« back to all changes in this revision

Viewing changes to users/mardelcourt/PROC_141512/PROC_141512/SubProcesses/finiteterms.f

  • Committer: John Doe
  • Date: 2013-03-25 20:27:02 UTC
  • Revision ID: john.doe@gmail.com-20130325202702-5sk3t1r8h33ca4p4
first clean version

Show diffs side-by-side

added added

removed removed

Lines of Context:
users/mardelcourt/PROC_141512/PROC_141512/SubProcesses/finiteterms.f
 
1
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
 
2
c FINITE PART OF THE INTEGRATE DIPOLES
 
3
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
 
4
c Returns fi(8):
 
5
c fi(1), regular piece at z!=1
 
6
c fi(2), delta piece at z=1
 
7
c fi(3), plus distribution at z!=1
 
8
c fi(4), plus distribution at z=1
 
9
c fi(5), mass correction to plus distribution at z!=1
 
10
c fi(6), mass correction to plus distribution at z=1
 
11
c fi(7), delta piece at z=1-4m^2/s
 
12
c fi(8), plus distribution at z!=1-4m^2/s
 
13
c fi(9), plus distribution at z=1-4m^2/s
 
14
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
 
15
 
 
16
 
 
17
      SUBROUTINE finiteff(mi,mk,sik,id,id1,fi)
 
18
c  calculates the finite terms when both emitter
 
19
c  and spectator are in the final state
 
20
      implicit none
 
21
 
 
22
      include "coupl.inc"
 
23
      include 'dipole.inc'
 
24
c Arguments
 
25
      REAL*8 mi,mk,sik,fi(9)
 
26
      INTEGER id,id1,i
 
27
c Global
 
28
      REAL*8 ddilog,lambda_tr
 
29
      external ddilog,lambda_tr
 
30
c Local
 
31
      REAl*8 cf,ca,rhoi,rhok,rho,musq_i,musq_k,gsq,pi
 
32
      REAL*8 xp,yp,vik,muk,rho1,rho2,L,yl,rs,Qik2,a,b,c,d,xm,x,mui
 
33
      PARAMETER (cf=4d0/3d0,ca=3d0)
 
34
      PARAMETER (pi=3.1415926535897932385d0)
 
35
      complex*16 test
 
36
 
 
37
      do i=1,9
 
38
         fi(i)=0d0
 
39
      enddo
 
40
 
 
41
c For the massive cases, sik is the Qik^2 from CDST and vice versa.
 
42
 
 
43
      musq_i=mi**2/sik
 
44
      musq_k=mk**2/sik
 
45
      muk=Sqrt(musq_k)
 
46
      mui=Sqrt(musq_i)
 
47
      Qik2=sik-mi**2-mk**2
 
48
      gsq=GG(1)**2
 
49
      L=DLog(mu**2/sik)
 
50
 
 
51
C  ij~ massive and massive spectator
 
52
      if(mi.gt.0d0 .and. mk .gt. 0d0.and.id.eq.1) then
 
53
         rs=0d0
 
54
         vik=Sqrt(lambda_tr(1d0,musq_i,musq_k))/(1d0-musq_i-musq_k)
 
55
         rhoi=Sqrt((1d0-vik+2d0*musq_i/(1d0-musq_i-musq_k))/
 
56
     &        (1d0+vik+2d0*musq_i/(1d0-musq_i-musq_k)))
 
57
         rhok=Sqrt((1d0-vik+2d0*musq_k/(1d0-musq_i-musq_k))/
 
58
     &        (1d0+vik+2d0*musq_k/(1d0-musq_i-musq_k)))
 
59
         rho=Sqrt((1d0-vik)/(1d0+vik))
 
60
         fi(2)=(gsq*(6 + 2*L + 2*rs + 
 
61
     &        2*mk*((4*mk - 2*Sqrt(sik))/Qik2 + 1/(mk - Sqrt(sik))) - 
 
62
     &        (2*Pi**2)/(3.*vik) - 4*Log(-mi**2 + (mk - Sqrt(sik))**2) + 
 
63
     &        2*Log(mi - (mi*mk)/Sqrt(sik)) - 
 
64
     &        (4*mi**2*Log(mi/(-mk + Sqrt(sik))))/Qik2 + 3*Log(sik) - 
 
65
     &        (-4*Log(rho**2)*Log(1 + rho**2) + Log(rhoi**2)**2 + 
 
66
     &        Log(rhok**2)**2 -
 
67
     &        4*Log(rho)*(L + 2*Log(sik/Qik2)))/(2.*vik) - 
 
68
     &        (2*(-2*ddilog(rho**2) + ddilog(1 - rhoi**2) + 
 
69
     &        ddilog(1 - rhok**2)))/vik))/(16.*Pi**2)
 
70
 
 
71
C adding alpha dependent terms
 
72
         if(alpha_ff.ne.1d0) then
 
73
            a=(2*muk)/(1 - musq_i - musq_k)
 
74
            b=(2*(1 - muk))/(1 - musq_i - musq_k)
 
75
            c=(2*(1 - muk)*muk)/(1 - musq_i - musq_k)
 
76
            d=(1 - musq_i - musq_k)/2.
 
77
            xp=(-musq_i + (1 - muk)**2 +
 
78
     &           Sqrt(lambda_tr(1d0,musq_i,musq_k)))/(1-musq_i-musq_k)
 
79
            xm=(-musq_i + (1 - muk)**2 -
 
80
     &           Sqrt(lambda_tr(1d0,musq_i,musq_k)))/(1-musq_i-musq_k)
 
81
            yp=1 - (2*(1 - muk)*muk)/(1 - musq_i - musq_k)
 
82
            x=yp - alpha_ff*yp + Sqrt(((4*musq_i*musq_k)/
 
83
     &           ((musq_i - (1 - muk)**2)*(1 - musq_i - musq_k)) +
 
84
     &           1/yp - alpha_ff*yp)*(yp - alpha_ff*yp))
 
85
            fi(2)=fi(2)+gsq*(1/(1- muk)-(2*(2-2*musq_i-muk))/
 
86
     &           (1-musq_i-musq_k)+(3*(1+alpha_ff*yp))/2. + 
 
87
     &           (musq_i*(1 - alpha_ff*yp))/(2.*(musq_i +
 
88
     &           alpha_ff*(1 - musq_i - musq_k)*yp)) - 
 
89
     &           2*DLog((alpha_ff*(1 - musq_i - musq_k)*yp)/
 
90
     &           (-musq_i + (1 - muk)**2)) + 
 
91
     &           ((1 + musq_i - musq_k)*
 
92
     &           DLog((musq_i + alpha_ff*(1 - musq_i - musq_k)*yp)
 
93
     &           /(1 - muk)**2))/(2.*(1 - musq_i - musq_k)) + 
 
94
     &           (2*(-(DLog(b)*DLog((a*(-b + xm))/((a + b)*xm))) +
 
95
     &           DLog(b - x)*DLog(((a + x)*(-b + xm))/
 
96
     &           ((a + b)*(-x + xm))) + 
 
97
     &           DLog((c + xm)/(a + xm))*DLog((-x + xm)/xm) +
 
98
     &           DLog(a*(b - xp))*DLog(xp) + 
 
99
     &           (DLog((a + x)/a)*DLog(a*(a + x)*(a + xp)**2))/2. -
 
100
     &           DLog(c)*DLog(((a - c)*xp)/(a*(c + xp))) + 
 
101
     &           DLog(d)*DLog(((a + x)*xm*xp)/(a*(-x + xm)*(-x + xp))) -
 
102
     &           DLog((a + x)*(b - xp))*DLog(-x + xp) + 
 
103
     &           DLog(c + x)*DLog(((a-c)*(-x + xp))/((a + x)*(c + xp)))-
 
104
     &           ddilog(b/(a + b)) + ddilog(c/(-a + c)) + 
 
105
     &           ddilog((b - x)/(a + b)) - ddilog((c + x)/(-a + c)) +
 
106
     &           ddilog(b/(b - xm)) - ddilog((b - x)/(b - xm)) -
 
107
     &           ddilog(xm/(a + xm)) + ddilog(xm/(c + xm)) +
 
108
     &           ddilog((-x + xm)/(a+xm)) - ddilog((-x + xm)/(c + xm))+
 
109
     &           ddilog(a/(a + xp)) - ddilog((a + x)/(a + xp)) -
 
110
     &           ddilog(xp/(-b + xp)) - ddilog(c/(c + xp)) +
 
111
     &           ddilog((c + x)/(c + xp)) +
 
112
     &           ddilog((-x + xp)/(-b + xp))))/vik)/(8.*Pi**2)
 
113
 
 
114
         endif
 
115
 
 
116
C ij~ massive and massless spectator
 
117
      elseif(mi.gt.0d0.and.mk.eq.0d0.and.id.eq.1) then
 
118
         rs=0d0
 
119
         fi(2)= (gsq*(72d0 + 6d0*L*(4d0 + L) - 11d0*Pi**2 + 24d0*rs + 
 
120
     &        (24d0*musq_i*DLog(musq_i))/(-1d0 + musq_i) + 
 
121
     &        6d0*(4d0*DLog(1 - musq_i)**2 + 
 
122
     &        (2d0 + 2d0*L - Log(musq_i))*DLog(musq_i) - 
 
123
     &        4d0*DLog(1d0 - musq_i)*(2d0 + L + DLog(musq_i))) - 
 
124
     &        24d0*ddilog(1d0 - musq_i)))/(192d0*Pi**2)
 
125
 
 
126
C adding alpha dependent terms
 
127
         if(alpha_ff.ne.1d0) then
 
128
            fi(2)=fi(2)+(gsq*(-2*DLog(alpha_ff) + 
 
129
     &           (2*DLog(alpha_ff+(1-alpha_ff)*musq_i))/(1-musq_i) + 
 
130
     &           (-2 + 3*alpha_ff-alpha_ff/(alpha_ff+(1-alpha_ff)*musq_i) - 
 
131
     &           ((3 - musq_i)*DLog(alpha_ff+(1-alpha_ff)*musq_i))/
 
132
     &           (1 - musq_i))/2. +2*(-(DLog(alpha_ff)*DLog(musq_i))- 
 
133
     &           ddilog((-1+ musq_i)/musq_i) + 
 
134
     &           ddilog((alpha_ff*(-1 + musq_i))/musq_i))))/(8.*pi**2)
 
135
         endif
 
136
 
 
137
C ij~ massless quark and massive spectator
 
138
      elseif(mi.eq.0d0 .and. mk.gt.0d0 .and. id.eq.1) then
 
139
         if(scheme .eq. 'HV') then
 
140
            rs=0d0
 
141
         elseif(scheme .eq. 'DR') then
 
142
            rs=-1d0/2d0
 
143
         endif
 
144
         fi(2)= (gsq*((36*L*(1 + muk) + 
 
145
     &        6*L**2*(1 + muk) - 11*Pi**2 + 
 
146
     &        24*(5 + rs) + muk*(-11*Pi**2 + 24*(2 + rs)) - 
 
147
     &        36*(1 + muk)*Log((-1 + muk)**2) - 6*(1 + muk)*
 
148
     &        (-4*Log(1 - musq_k)**2 + Log(musq_k)*(-2*L + Log(musq_k))+ 
 
149
     &        4*Log(1 - musq_k)*(L + Log(musq_k))))/(1 + muk) 
 
150
     &        - 24*ddilog(1 - musq_k)))/
 
151
     &        (192.*Pi**2)
 
152
 
 
153
C adding alpha dependent terms
 
154
         if(alpha_ff.ne.1d0) then
 
155
            yp=(1d0-musq_k)/(1d0+musq_k)
 
156
            xp=yp*(1d0-alpha_ff)+
 
157
     &           Sqrt((1d0-alpha_ff)*(1d0-alpha_ff*yp**2))
 
158
            fi(2)=fi(2)+(gsq*((-3*((1-alpha_ff)*yp+DLog(alpha_ff)))/2. + 
 
159
     &           2*(-DLog((1-xp+yp)/(1+yp))**2+DLog((1+2*xp*yp-yp**2)/
 
160
     &           ((1 + xp - yp)*(1 - xp + yp)))**2/2. + 
 
161
     &           2*(DLog((1+xp-yp)/(1-yp))*DLog((1+yp)/2.) + 
 
162
     &           DLog((1+yp)/(2.*yp))*DLog((1+2*xp*yp-yp**2)/(1-yp**2))- 
 
163
     &           ddilog((1-yp)/2.) +ddilog((1 + xp - yp)/2.) + 
 
164
     &           ddilog((1 - yp)/(1 + yp)) - 
 
165
     &           ddilog((1+2*xp*yp-yp**2)/(1+yp)**2)))
 
166
     &           ))/(8.*pi**2)
 
167
         endif
 
168
 
 
169
 
 
170
C ij~ massless quark and massless spectator
 
171
      elseif(mi.eq.0d0 .and. mk.eq.0d0 .and. id.eq.1) then
 
172
         if(scheme .eq. 'HV') then
 
173
            rs=0d0
 
174
         elseif(scheme .eq. 'DR') then
 
175
            rs=-1d0/2d0
 
176
         endif
 
177
         fi(2)=(gsq*(6*L*(3+L)-7*pi**2+12*(5+rs)))/(96.*pi**2)
 
178
         
 
179
C     adding alpha dependent terms
 
180
         if (alpha_ff.ne.1d0) then
 
181
            fi(2)=fi(2)+((gsq*((3*(-1 + alpha_ff - DLog(alpha_ff)))/2.
 
182
     &           - DLog(alpha_ff)**2))/(8.*pi**2))
 
183
         endif
 
184
 
 
185
 
 
186
C ij~ gluon and massive spectator
 
187
      elseif(mk.gt.0d0.and. id.eq.0) then
 
188
         if(scheme .eq. 'HV') then
 
189
            rs=0d0
 
190
         elseif(scheme .eq. 'DR') then
 
191
            rs=-1d0/6d0
 
192
         endif
 
193
C  1. g->QQ splitting
 
194
       if(id1.eq.1.and.mi.gt.0d0) then
 
195
          fi(2)=(gsq*((2*(1 - (4*musq_i)/(-1 + muk)**2)**1.5*muk)/
 
196
     &         (1 + muk) + (8*Sqrt(1 - (4*musq_i)/(-1 + muk)**2)*
 
197
     &         (1 + mui - muk)*(-1 + mui + muk))/(3.*(-1 + muk)**2)
 
198
     &         - 2*DLog(mui) + 2*DLog((1 +
 
199
     &         Sqrt(1 - (4*musq_i)/(-1 + muk)**2))/2.)+2*DLog(1 - muk)- 
 
200
     &         (2*musq_k*((8*musq_i*Sqrt(1 - (4*musq_i)/(-1 + muk)**2))/
 
201
     &         (-1 + musq_k)-DLog((1-Sqrt(1-(4*musq_i)/(-1 + muk)**2))/
 
202
     &         (1 + Sqrt(1 - (4*musq_i)/(-1 + muk)**2))) + 
 
203
     &         ((-1 + 4*musq_i + musq_k)/(-1 + musq_k))**1.5*
 
204
     &         DLog((-Sqrt(1 - (4*musq_i)/(-1 + muk)**2) +
 
205
     &         Sqrt((-1 + 4*musq_i + musq_k)/(-1 + musq_k)))/
 
206
     &         (Sqrt(1 - (4*musq_i)/(-1 + muk)**2) +
 
207
     &         Sqrt((-1 + 4*musq_i + musq_k)/(-1 + musq_k))))))
 
208
     &         /(1 - musq_k)))/(24.*Pi**2)/ca
 
209
 
 
210
 
 
211
C adding alpha dependent terms
 
212
          if(alpha_ff.ne.1d0) then
 
213
           a=1.-musq_k
 
214
           c=-1.+2*musq_i+musq_k
 
215
           yp=1.-2*muk*(1.-muk)/(1.-2*musq_i-musq_k)
 
216
           b=sqrt(c**2*yp**2-4.*musq_i**2)
 
217
           d=sqrt(alpha_ff*c**2*yp**2-4.*musq_i**2)
 
218
           fi(2)=fi(2)-gsq*((c*Sqrt(-c + 2*musq_i)*(4*(b - d)*musq_i**2 
 
219
     &          + c**2*yp*(-2*alpha_ff*b-d*(-2+yp) + alpha_ff**2*b*yp)+ 
 
220
     &          4*c*musq_i*(d - d*yp + b*(-1 + alpha_ff*yp))) - 
 
221
     &          2*b*d*Sqrt(-c + 2*musq_i)*
 
222
     &          (c**2 - 2*(1 + c)*musq_i + 4*musq_i**2)
 
223
     &          *DATAN((2*musq_i)/Sqrt(-4*musq_i**2 + c**2*yp**2)) + 
 
224
     &          2*b*d*Sqrt(-c + 2*musq_i)*
 
225
     &          (c**2 - 2*(1 + c)*musq_i + 4*musq_i**2)
 
226
     &          *DATAN((2*musq_i)/
 
227
     &          Sqrt(-4*musq_i**2 + alpha_ff**2*c**2*yp**2)) + 
 
228
     &          b*d*(2*a*(c + c**2 + 2*musq_i - 4*musq_i**2)*
 
229
     &          DLog(-((-c - 2*musq_i)**2.5
 
230
     &          *(1 + c - 2*musq_i)*(-1 + yp))) - 
 
231
     &          2*a*(c + c**2 + 2*musq_i - 4*musq_i**2)*
 
232
     &          DLog((-c - 2*musq_i)**2.5
 
233
     &          *(1 + c - 2*musq_i)*(1 - alpha_ff*yp)) + 
 
234
     &          2*c*Sqrt(-c + 2*musq_i)*DLog(-2*(b + c*yp)) 
 
235
     &          + 3*c**2*Sqrt(-c + 2*musq_i)*DLog(-2*(b + c*yp)) - 
 
236
     &          4*c*musq_i*Sqrt(-c + 2*musq_i)*DLog(-2*(b + c*yp)) 
 
237
     &          - 2*c*Sqrt(-c + 2*musq_i)*Log(-2*(d + alpha_ff*c*yp)) - 
 
238
     &          3*c**2*Sqrt(-c + 2*musq_i)*DLog(-2*(d + alpha_ff*c*yp)) 
 
239
     &          + 4*c*musq_i*Sqrt(-c + 2*musq_i)*
 
240
     &          DLog(-2*(d + alpha_ff*c*yp)) - 
 
241
     &          2*a*c*DLog(-4*musq_i**2 - b*Sqrt(c**2 - 4*musq_i**2) +
 
242
     &          c**2*yp) - 2*a*c**2*DLog(-4*musq_i**2 -
 
243
     &          b*Sqrt(c**2 - 4*musq_i**2) + c**2*yp) - 
 
244
     &          4*a*musq_i*DLog(-4*musq_i**2 - b*Sqrt(c**2 - 4*musq_i**2)
 
245
     &          + c**2*yp) + 8*a*musq_i**2*DLog(-4*musq_i**2 -
 
246
     &          b*Sqrt(c**2 - 4*musq_i**2) + c**2*yp) + 
 
247
     &          2*a*c*DLog(-4*musq_i**2 - d*Sqrt(c**2 - 4*musq_i**2) +
 
248
     &          alpha_ff*c**2*yp) + 2*a*c**2*Log(-4*musq_i**2 -
 
249
     &          d*Sqrt(c**2 - 4*musq_i**2) + alpha_ff*c**2*yp) + 
 
250
     &          4*a*musq_i*DLog(-4*musq_i**2 - d*Sqrt(c**2 - 4*musq_i**2)
 
251
     &          + alpha_ff*c**2*yp) - 8*a*musq_i**2*DLog(-4*musq_i**2 -
 
252
     &          d*Sqrt(c**2 - 4*musq_i**2) + alpha_ff*c**2*yp)))/
 
253
     &          (3.*c*(-c+2*musq_i)**1.5*Sqrt(-4*musq_i**2 + c**2*yp**2)
 
254
     &          *Sqrt(-4*musq_i**2+alpha_ff**2*c**2*yp**2)))/
 
255
     &          (8.*Pi**2)/ca
 
256
 
 
257
 
 
258
          endif
 
259
 
 
260
C  2. g->qq splitting
 
261
       elseif(id1.eq.1.and. mi.eq.0d0) then
 
262
          fi(2)=(gsq*((-1 + muk)*(-6*L*(1 + muk) - 4*(4 + muk)
 
263
c$$$     &         + 9*(1 + muk)*rs) + 12*(-1 + muk**2)*DLog(1 - muk) + 
 
264
c     RF No scheme dependence here. All in the g -> gg.
 
265
     &         ) + 12*(-1 + musq_k)*DLog(1 - muk) + 
 
266
     &         12*musq_k*DLog((2*muk)/(1 + muk))))/
 
267
     &         (144.*(-1 + musq_k)*pi**2)/ca
 
268
C     adding alpha dependent terms
 
269
          if(alpha_ff.ne.1d0) then
 
270
             fi(2)=fi(2)-(gsq*(-((-1 + alpha_ff)*(-1 + muk)**2) + 
 
271
     &            DLog(alpha_ff) + musq_k*(DLog(4d0) + DLog(1/alpha_ff)
 
272
     &            + 2*DLog(muk) - 2*DLog(1 + muk) - 
 
273
     &            2*DLog(1+alpha_ff-(2*alpha_ff)/(1+muk))))/
 
274
     &            (3.*(-1+musq_k)))/(8.*pi**2)/ca
 
275
          endif
 
276
 
 
277
C  3. g->gg splitting
 
278
       elseif(id1.eq.0) then
 
279
          fi(2)=(gsq*((200 + 66*L + 9*L**2-(132*muk)/(1 + muk)-15*Pi**2
 
280
     &         - 132*DLog(1 - muk) - (24*musq_k*DLog((2*muk)/(1 +
 
281
     &         muk)))/(-1 + musq_k) +66*DLog(1 - musq_k) + 9*(4*(L -
 
282
     &         DLog(muk))*DLog(muk) - 2*(L + 2*DLog(muk))*DLog(1 -
 
283
     &         musq_k) + DLog(1 - musq_k)**2) - 36*ddilog(1 - musq_k)))
 
284
     &         /18d0)/(8.*pi**2)
 
285
 
 
286
C     adding alpha dependent terms
 
287
          if (alpha_ff.ne.1d0) then
 
288
             yl=1d0 + alpha_ff*(-1 + muk)**2 - musq_k - 
 
289
     &            Sqrt(abs((-1+muk)**2*(alpha_ff**2*(-1+muk)**2+
 
290
     &            (1+muk)**2-2*alpha_ff*(1+musq_k))))
 
291
             fi(2)=fi(2)-(gsq*((11*(-2+2*muk+yl)**2)/
 
292
     &            ((-1+musq_k)*(-2+yl))
 
293
     &            -44*Log(2-2*muk) - 22*Log(muk) + 24*Log(2/(1 + muk))*
 
294
     &            (Log(2/(1 + muk)) + 2*Log(1 + muk)) +
 
295
     &            (2*((-11 + 15*musq_k)*Log(2*muk) + 
 
296
     &            4*musq_k*(-Log(-8*(-1+muk)*musq_k)+
 
297
     &            Log((-2 + yl)**2+4*musq_k*(-1 + yl))) + 
 
298
     &            (11 - 15*musq_k)*Log(2 - yl)))/(-1 + musq_k) + 
 
299
     &            22*Log(2 - 2*musq_k - yl) + 
 
300
     &            22*Log(yl)-12*(4*Log(1-yl/2.)*Log(-(yl/(-1+musq_k)))-
 
301
     &            Log(-(yl/(-1+musq_k)))**2 + 
 
302
     &            Log((-2*(-2 + 2*musq_k + yl))/
 
303
     &            ((-1 + musq_k)*(-2 + yl)))**2 + 
 
304
     &            2*Log(-(yl/(-1+musq_k)))*(
 
305
     &            Log((-2*(-2+2*musq_k+yl))/((-1+musq_k)*(-2+yl))) - 
 
306
     &            2*Log(1 + yl/(-2 + 2*musq_k)))) + 48*ddilog(1 - muk) -
 
307
     &            48*ddilog(1/(1 + muk)) - 
 
308
     &            48*ddilog(yl/2.) + 48*ddilog(yl/(2 - 2*musq_k))))/
 
309
     &            (48.*pi**2)
 
310
          endif
 
311
       endif
 
312
 
 
313
C ij~ gluon and massless spectator
 
314
      elseif(mk.eq.0d0.and.id.eq.0) then
 
315
         if(scheme .eq. 'HV') then
 
316
            rs=0d0
 
317
         elseif(scheme .eq. 'DR') then
 
318
            rs=-1d0/6d0
 
319
         endif
 
320
C     1. g->QQ splitting
 
321
         if(id1.eq.1.and.mi.gt.0d0) then
 
322
            fi(2)=(gsq*(-16*Sqrt(1-4*musq_i)+16*musq_i*Sqrt(1-4*musq_i)+
 
323
c$$$     &           9*rs-12*DLog(Sqrt(musq_i))+ 
 
324
c     RF No scheme dependence here. All in the g -> gg.
 
325
     &           12*DLog(Sqrt(musq_i))+ 
 
326
     &           12*DLog((1 + Sqrt(1 - 4*musq_i))/2.)))/(144.*pi**2)/ca
 
327
C adding alpha dependent terms
 
328
            if (alpha_ff.ne.1d0) then
 
329
               fi(2)=fi(2)-(gsq*(Sqrt(1-4*musq_i)+
 
330
     &              Sqrt(-4*musq_i**2+alpha_ff**2*(1-2*musq_i)**2) + 
 
331
     &              (2*Sqrt(-4*musq_i**2+alpha_ff**2*(1-2*musq_i)**2))/
 
332
     &              (-alpha_ff+2*(-1+alpha_ff)*musq_i) + 
 
333
     &              (-1 + 2*musq_i)*(-2*DATAN((2*musq_i)/
 
334
     &              Sqrt(1 - 4*musq_i)) + 
 
335
     &              2*DATan((2*musq_i)/
 
336
     &              Sqrt(-4*musq_i**2 + alpha_ff**2*(1 - 2*musq_i)**2))+ 
 
337
     &              DLog(-2*(-1 + 2*musq_i + Sqrt(1 - 4*musq_i))) - 
 
338
     &              DLog(-2*(alpha_ff*(-1+2*musq_i)+
 
339
     &              Sqrt(-4*musq_i**2+alpha_ff**2*(1-2*musq_i)**2))))))/
 
340
     &              (24.*pi**2)/ca
 
341
            endif
 
342
C  2. g->qq splitting
 
343
         elseif(id1.eq.1.and. mi.eq.0d0) then
 
344
c$$$            fi(2)=-(gsq*(8 + 3*L - 9*rs*ca))/(144.*pi**2)/ca
 
345
c     RF No scheme dependence here. All in the g -> gg.
 
346
            fi(2)=-(gsq*(8 + 3*L))/(144.*pi**2)/ca
 
347
 
 
348
C adding alpha dependent terms
 
349
            if (alpha_ff.ne.1d0) then
 
350
               fi(2)=fi(2)-(gsq*(-1 + alpha_ff - DLog(alpha_ff)))/
 
351
     &              (24.*pi**2)/ca
 
352
            endif
 
353
 
 
354
C  3. g->gg splitting
 
355
         elseif(id1.eq.0) then
 
356
            fi(2)=(gsq*((200+6*L*(11+3*L)-21*pi**2)+36*rs))/(144.*pi**2)
 
357
 
 
358
C adding alpha dependent terms
 
359
            if (alpha_ff.ne.1d0) then
 
360
               fi(2)=fi(2)-(gsq*(11-11*alpha_ff+11*DLog(alpha_ff)+
 
361
     &              6*DLog(alpha_ff)**2))/(24.*pi**2)
 
362
            endif
 
363
         endif
 
364
      endif
 
365
 
 
366
      end
 
367
 
 
368
 
 
369
      SUBROUTINE finitefi(mi,sik,sikzone,x,id1,id2,fi)
 
370
c  calculates the finite terms when emitter is in
 
371
c  final state and spectator is in initial state
 
372
      implicit none
 
373
 
 
374
      include "coupl.inc"
 
375
      include 'dipole.inc'
 
376
c Arguments
 
377
      REAL*8 mi,qsq,sik,x,fi(9),sikzone
 
378
      INTEGER id1,id2
 
379
c Global
 
380
      REAL*8 ddilog
 
381
      external ddilog
 
382
c Local
 
383
      INTEGER i
 
384
      REAl*8 cf,ca,rhoi,rhok,rho,musq_i,gsq,pi
 
385
      REAL*8 L,L_one,rs,musq_i_one
 
386
      PARAMETER (cf=4d0/3d0,ca=3d0)
 
387
      PARAMETER (pi=3.1415926535897932385d0)
 
388
 
 
389
      musq_i=mi**2/sik
 
390
      musq_i_one=mi**2/sikzone
 
391
      gsq=GG(1)**2
 
392
      L_one=DLog(mu**2/sikzone)
 
393
 
 
394
      do i=1,9
 
395
         fi(i)=0d0
 
396
      enddo
 
397
 
 
398
C  massive quark (ij~: quark)
 
399
      if(mi .gt. 0d0 .and. id1.eq.1) then
 
400
         rs=0d0
 
401
         fi(2)=(gsq*((1d0+DLOG(musq_i_one/(musq_i_one+1d0)))*L_one
 
402
     &        -2d0*ddilog(-musq_i_one)-pi**2/3d0+2d0+
 
403
     &        DLOG(musq_i_one)**2/2d0+DLOG(1+musq_i_one)**2/2d0-
 
404
     &        2d0*DLOG(musq_i_one)*DLOG(1+musq_i_one)+DLOG(musq_i_one)))
 
405
     &        /(8.*pi**2)
 
406
 
 
407
c adding the alpha dependent term
 
408
         if(alpha_fi.ne.1d0) then
 
409
            fi(2)=fi(2)+gsq/(8.*pi**2)*2.*DLog(alpha_fi)*
 
410
     &           (DLog((1d0+musq_i_one)/(musq_i_one))-1d0)
 
411
         endif
 
412
         if(x.gt.(1d0-alpha_fi)) then
 
413
            fi(1)=gsq/(8.*pi**2)*((1.-x)/(2.*(1-x+musq_i)**2)+2./
 
414
     &           (1-x)*DLog(((2.-x+musq_i)*musq_i_one)
 
415
     &           /((1.+musq_i_one)*(1-x+musq_i))))
 
416
            fi(3)=gsq/(8.*pi**2)*2./(1-x)*
 
417
     &           (DLOG((1+musq_i_one)/(musq_i_one))-1d0)
 
418
            fi(4)=fi(3)
 
419
         endif
 
420
 
 
421
C  massless quark (ij~: quark)
 
422
      elseif(mi.eq.0d0 .and. id1.eq.1) then
 
423
         if(scheme .eq. 'HV') then
 
424
            rs=0d0
 
425
         elseif(scheme .eq. 'DR') then
 
426
            rs=-1d0/2d0
 
427
         endif
 
428
         fi(2)=(gsq*(6*(7+L_one*(3+L_one))-7*pi**2+12*rs))/(96.*pi**2)
 
429
c     adding the alpha dependent term
 
430
         if (alpha_fi.ne.1d0) then
 
431
            fi(2)=fi(2)+gsq/(8.*pi**2)*(-3./2.*Dlog(alpha_fi)-
 
432
     &           Dlog(alpha_fi)**2)
 
433
         endif
 
434
         if(x.gt.(1d0-alpha_fi)) then
 
435
            fi(1)=gsq/(4d0*pi**2*(1-x))*DLog(2d0-x)
 
436
            fi(3)=-(gsq*(3/(1-x)+(4*DLog(1-x))/(1-x)))/(16.*pi**2)
 
437
            fi(4)=fi(3)
 
438
         endif
 
439
 
 
440
C  gluon (ij~: gluon)
 
441
      elseif(id1.eq.0) then
 
442
         if(scheme .eq. 'HV') then
 
443
            rs=0d0
 
444
         elseif(scheme .eq. 'DR') then
 
445
            rs=-1d0/6d0
 
446
         endif
 
447
C  1. g-> QQ (i:massive quark )
 
448
         if(id2.eq.1.and.mi.gt.0d0) then
 
449
            fi(7)=-(gsq*(5*Sqrt(1-4*musq_i_one)+
 
450
     &           4*musq_i_one*Sqrt(1-4*musq_i_one)+DLog(64d0) + 
 
451
     &           3*DLog(musq_i_one) -
 
452
     &           6*DLog(1+Sqrt(1-4*musq_i_one))))/(72.*pi**2)/ca
 
453
c adding the alpha dependent term
 
454
            if (alpha_fi.ne.1d0) then
 
455
               fi(7)=fi(7)+(gsq*((5 - 16*musq_i_one**2 -
 
456
     &              5*Sqrt(((1 - 4*musq_i_one)*
 
457
     &              (alpha_fi - 4*musq_i_one))/alpha_fi) - 
 
458
     &              4*musq_i_one*(4 + Sqrt(((1 - 4*musq_i_one)*
 
459
     &              (alpha_fi - 4*musq_i_one))/
 
460
     &              alpha_fi**3)))/Sqrt(1 - 4*musq_i_one)-
 
461
     &              6*DLog(1+Sqrt(1-4*musq_i_one)) + 
 
462
     &              6*DLog(Sqrt(alpha_fi)+
 
463
     &              Sqrt(alpha_fi-4*musq_i_one))))/(72.*pi**2)/ca
 
464
            endif
 
465
            if(x.lt.1d0-4d0*musq_i)then
 
466
               if(x.gt.(1d0-alpha_fi)) then
 
467
                  fi(8)=(gsq*Sqrt(1+(4*musq_i)/(-1 +x))*
 
468
     &                 (1 + 2*musq_i - x))/(24.*pi**2*(-1 + x)**2)/ca
 
469
                  fi(9)=fi(8)
 
470
               endif
 
471
            endif
 
472
 
 
473
c  2. g-> qq (i:massless quark)
 
474
         elseif(id2.eq.1.and.mi.eq.0d0) then
 
475
c     RF No scheme dependence here. All in the g -> gg.
 
476
            fi(2)=-(gsq*(10 + 6*L_one))/(144.*pi**2)/ca
 
477
c     adding the alpha dependent term
 
478
            if(alpha_fi.ne.1d0) then
 
479
               fi(2)=fi(2)+gsq/(8d0*pi**2)*DLog(alpha_fi)/3./ca
 
480
            endif
 
481
            if(x.gt.(1d0-alpha_fi)) then
 
482
               fi(3)=gsq/(24.*pi**2*(1 - x))/ca
 
483
               fi(4)=fi(3)
 
484
            endif
 
485
 
 
486
C  3. g-> gg (i: gluon )
 
487
         elseif(id2.eq.0) then
 
488
            fi(2)=(gsq*(134 + 6*L_one*(11 + 3*L_one) -
 
489
     &           21*pi**2 + 36*rs))/(144.*pi**2)
 
490
c adding the alpha dependent term
 
491
            if (alpha_fi.ne.1d0) then
 
492
               fi(2)=fi(2)+gsq/(8.*pi**2)*
 
493
     &              (-2d0*DLOG(alpha_fi)**2-11d0/3d0*DLOG(alpha_fi))
 
494
            endif
 
495
            if(x.gt.(1d0-alpha_fi)) then
 
496
               fi(1)=-(gsq*DLog(2 - x))/(2.*pi**2*(-1 + x))
 
497
               fi(3)=(gsq*(-11/(1-x)+(12*DLog(1-x))/(-1+x)))/(24.*pi**2)
 
498
               fi(4)=fi(3)
 
499
            endif
 
500
         endif
 
501
      endif
 
502
 
 
503
      end
 
504
 
 
505
 
 
506
      SUBROUTINE finiteif(mk,sik,sikzone,x,id1,id2,fi)
 
507
c  calculates the finite terms when the emitter is
 
508
c  in the initial state and the spectator is in the
 
509
c  final state.
 
510
      implicit none
 
511
      include "coupl.inc"
 
512
      include "dipole.inc"
 
513
 
 
514
c Arguments
 
515
      REAL*8 mk,sik,sikzone,x,fi(9)
 
516
      INTEGER id1,id2
 
517
c Global
 
518
      REAL*8 ddilog
 
519
      external ddilog
 
520
c Local
 
521
      INTEGER i
 
522
      REAl*8 cf,ca,pi,gsq
 
523
      REAL*8 zp,musq_k,L,L_one,rs,musq_k_one
 
524
      PARAMETER (cf=4d0/3d0,ca=3d0)
 
525
      PARAMETER (pi=3.1415926535897932385d0)
 
526
 
 
527
      gsq=GG(1)**2
 
528
      musq_k=mk**2/sik
 
529
      musq_k_one=mk**2/sikzone
 
530
      zp=(1d0-x)/(1d0-x+musq_k)
 
531
      L=DLog(mu**2/sik)
 
532
      L_one=DLog(mu**2/sikzone)
 
533
 
 
534
      do i=1,9
 
535
         fi(i)=0d0
 
536
      enddo
 
537
      
 
538
c quark-quark splitting
 
539
      if(id1 .eq.1.and.id2.eq.1) then
 
540
         if(scheme .eq. 'HV') then
 
541
            rs=0d0
 
542
         elseif(scheme .eq. 'DR') then
 
543
            rs=-1d0/2d0
 
544
         endif
 
545
         fi(2)=(gsq*(2*L_one**2-pi**2+4*rs+6*DLog(mu**2/muf**2) + 
 
546
     &        2*DLog(1 + musq_k_one)*(2*L_one + DLog(1 + musq_k_one)) + 
 
547
     &        8*ddilog(1/(1 + musq_k_one))))/(32.*pi**2)
 
548
         fi(1)=-(gsq*(-((-1 + x**2)*(L - DLog(mu**2/muf**2)))+ 
 
549
     &        (-1+x**2)*DLog(1 - x) - 2*DLog(2 - x) + 
 
550
     &        (-1+x)*(-1 + x +(1+x)*DLog((-1+x)/(-1-musq_k+x)))))/
 
551
     &        (8.*pi**2*(-1 + x))
 
552
         fi(3)=(gsq*(L-DLog(mu**2/muf**2)-2*DLog(1 - x)))/
 
553
     &        (4.*pi**2*(-1 + x))
 
554
         fi(4)=(gsq*(L_one-DLog(mu**2/muf**2)-2*DLog(1 - x)))/
 
555
     &        (4.*pi**2*(-1 + x))
 
556
         if (mk.ne.0d0) then
 
557
            fi(5)=gsq/(4d0*pi**2)*Dlog((2d0-x)/(2d0-x+musq_k))/(1d0-x)
 
558
            fi(6)=gsq/(4d0*pi**2)*Dlog(1d0/(1d0+musq_k_one))/(1d0-x)
 
559
         endif
 
560
c adding the alpha dependent term
 
561
         if(zp.gt.alpha_if) then
 
562
            fi(1)=fi(1)-(gsq*(-((1+x)*DLog(zp/alpha_if)) + 
 
563
     &           (2*DLog(((1+alpha_if-x)*zp)/(alpha_if*(1-x+zp))))/
 
564
     &           (1 - x)))/(8.*pi**2)
 
565
         endif
 
566
 
 
567
c quark-gluon splitting (i:quark, ij~: gluon)
 
568
      elseif(id1.eq.1.and.id2.eq.0 ) then
 
569
         fi(1)=(cf*gsq*(x**2 - L*(2 + (-2 + x)*x) + 
 
570
     &        (2 + (-2 + x)*x)*DLog(mu**2/muf**2) + 
 
571
     &        (2 + (-2 + x)*x)*DLog(1 - x) + 
 
572
     &        (2 + (-2 + x)*x)*DLog((-1 + x)/(-1 - musq_k + x))))/
 
573
     &        (8.*pi**2*x)/ca
 
574
c adding the alpha dependent term
 
575
         if(zp.gt.alpha_if) then
 
576
            if(musq_k.gt.0d0) then
 
577
               fi(1)=fi(1)-
 
578
     &              (cf*gsq*((2*musq_k*DLog((1 - zp)/(1 - alpha_if)))/x 
 
579
     &              + ((1 + (1 - x)**2)*DLog(zp/alpha_if))/x))/
 
580
     &              (8.*pi**2)/ca
 
581
            elseif(musq_k.eq.0d0) then
 
582
               fi(1)=fi(1)-(cf*gsq*(2-2*x+x**2)*
 
583
     &              DLog(zp/alpha_if))/(8.*pi**2*x)/ca
 
584
            endif
 
585
         endif
 
586
 
 
587
c gluon-quark splitting (i:gluon, ij~: quark)
 
588
      elseif(id1.eq.0.and.id2.eq.1) then
 
589
         fi(1)=(gsq*(-L + 2*(1 + L)*x - 2*(1 + L)*x**2 + 
 
590
     &        (1 + 2*(-1 + x)*x)*DLog(mu**2/muf**2) + 
 
591
     &        (1 + 2*(-1 + x)*x)*DLog(1 - x) + 
 
592
     &        (1 + 2*(-1 + x)*x)*DLog((-1 + x)/(-1 - musq_k + x))))
 
593
     &        /(16.*pi**2)/cf
 
594
c adding the alpha dependent term
 
595
         if(zp.gt.alpha_if) then
 
596
            fi(1)=fi(1)-(gsq*((1-x)**2+x**2)*
 
597
     &           DLog(zp/alpha_if))/(16.*pi**2)/cf
 
598
         endif
 
599
 
 
600
c gluon-gluon splitting (i:gluon, ij~:gluon)
 
601
      elseif(id1.eq.0.and.id2.eq.0) then
 
602
         if(scheme .eq. 'HV') then
 
603
            rs=0d0
 
604
         elseif(scheme .eq. 'DR') then
 
605
            rs=-1d0/6d0
 
606
         endif
 
607
         if(musq_k.gt.0d0) then
 
608
            fi(2)=(gsq*(6*L_one**2 - 3*pi**2 + 12*rs 
 
609
     &           + (22 - 4*Nf/ca)*DLog(mu**2/muf**2) + 
 
610
     &           6*DLog(1 + musq_k_one)*(2*L_one + Log(1 + musq_k_one)) 
 
611
     &           + 24*ddilog(1/(1 + musq_k_one))))/(96.*pi**2)
 
612
            fi(1)=(gsq*(L - 3*L*x + 3*L*x**2 - 2*L*x**3 + L*x**4 - 
 
613
     &           (-1 + x)*(-1 + x*(2 + (-1 + x)*x))*DLog(mu**2/muf**2) - 
 
614
     &           (-1 + x)*(-1 + x*(2 + (-1 + x)*x))*DLog(1 - x) 
 
615
     &           + x*DLog(2 - x) - musq_k*DLog(musq_k/(1 + musq_k - x))
 
616
     &           + musq_k*x*DLog(musq_k/(1 + musq_k - x)) - 
 
617
     &           (-1 + x)*(-1 + x*(2 + (-1 + x)*x))*Log((-1 + x)/
 
618
     &           (-1 - musq_k + x))))/(4.*pi**2*(-1 + x)*x)
 
619
            fi(4)=(gsq*(L_one - DLog(mu**2/muf**2) - 2*DLog(1 - x)))/
 
620
     &           (4.*pi**2*(-1 + x))
 
621
            fi(3)=(gsq*(L - DLog(mu**2/muf**2) - 2*DLog(1 - x)))/
 
622
     &           (4.*pi**2*(-1 + x))
 
623
            fi(5)=gsq/(4d0*pi**2)*DLog((2d0-x)/(2d0-x+musq_k))/(1d0-x)
 
624
            fi(6)=gsq/(4d0*pi**2)*Dlog((1d0)/(1d0+musq_k_one))/(1d0-x)
 
625
c     adding the alpha dependent term
 
626
            if(zp.gt.alpha_if) then
 
627
               fi(1)=fi(1)+(gsq*((-2*musq_k*DLog((1-zp)/(1-alpha_if)))/x 
 
628
     &              -2*(-1+(1 - x)/x + (1 - x)*x)*DLog(zp/alpha_if) + 
 
629
     &              (2*DLog((alpha_if*(1-x+zp))/((1+alpha_if-x)*zp)))/
 
630
     &              (1 - x)))/(8.*pi**2)
 
631
            endif
 
632
         elseif(musq_k.eq.0d0) then
 
633
            fi(2)=(gsq*((6*L_one**2 + pi**2) + 12*rs 
 
634
     &           + (22 - 4*Nf/ca)*DLog(mu**2/muf**2)))/(96.*pi**2)
 
635
            fi(1)=(gsq*((-1 + x*(2 + (-1 + x)*x))*
 
636
     &           (L-DLog(mu**2/muf**2)-DLog(1-x))-
 
637
     &           x*Dlog(2-x)/(1-x)))/(4.*pi**2*x)
 
638
            fi(4)=(gsq*(L_one-DLog(mu**2/muf**2)-2*DLog(1-x)))/
 
639
     &           (4.*pi**2*(-1 + x))
 
640
            fi(3)=(gsq*(L-DLog(mu**2/muf**2)-2*DLog(1-x)))/
 
641
     &           (4.*pi**2*(-1 + x))
 
642
c     adding the alpha dependent term
 
643
            if(zp.gt.alpha_if) then
 
644
               fi(1)=fi(1)+(gsq*((1 - 3*x + 3*x**2 
 
645
     &              - 2*x**3 + x**4)*DLog(zp/alpha_if) - 
 
646
     &              x*DLog((alpha_if*(1 - x + zp))/
 
647
     &              ((1 + alpha_if - x)*zp))))/(4.*pi**2*(-1 + x)*x)
 
648
            endif
 
649
         endif
 
650
      endif
 
651
 
 
652
      end
 
653
 
 
654
 
 
655
      SUBROUTINE finiteii(sik,sikzone,x,id1,id2,fi)
 
656
c  calculates the finite terms when both emitter
 
657
c  and spectator are in the initial state.
 
658
      implicit none
 
659
      include "coupl.inc"
 
660
      include "dipole.inc"
 
661
 
 
662
c Arguments
 
663
      REAL*8 sik,sikzone,x,fi(9)
 
664
      INTEGER id1,id2
 
665
c Global
 
666
      REAL*8 ddilog
 
667
      external ddilog
 
668
c Local
 
669
      INTEGER i
 
670
      REAl*8 cf,ca,pi,gsq
 
671
      REAL*8 L,L_one,rs
 
672
      PARAMETER (cf=4d0/3d0,ca=3d0)
 
673
      PARAMETER (pi=3.1415926535897932385d0)
 
674
 
 
675
      gsq=GG(1)**2
 
676
      L=dlog(mu**2/sik)
 
677
      L_one=dlog(mu**2/sikzone)
 
678
 
 
679
      do i=1,9
 
680
         fi(i)=0d0
 
681
      enddo
 
682
 
 
683
c quark-quark splitting (i:quark, ij~: quark)
 
684
      if(id1 .eq.1.and.id2.eq.1) then
 
685
         if(scheme .eq. 'HV') then
 
686
            rs=0d0
 
687
         elseif(scheme .eq. 'DR') then
 
688
            rs=-1d0/2d0
 
689
         endif
 
690
         fi(2)=(gsq*(2*L_one**2-pi**2+4*rs+6*DLog(mu**2/muf**2)))/
 
691
     &        (32.*pi**2)
 
692
         fi(1)=-(gsq*(-1 + x + (-1 - x)*(L -dLog(mu**2/muf**2)) 
 
693
     &        + 2*(1 + x)*dLog(1 - x)))/(8.*pi**2)
 
694
         fi(4)=-(gsq*((2*(L_one - dLog(mu**2/muf**2)))/(1 - x)
 
695
     &        + (4*dLog(1 - x))/(-1 + x)))/(8.*pi**2)
 
696
         fi(3)=-(gsq*((2*(L - dLog(mu**2/muf**2)))/(1 - x)
 
697
     &        + (4*dLog(1 - x))/(-1 + x)))/(8.*pi**2)
 
698
c     adding the alpha dependent term
 
699
         if((1d0-x).gt.alpha_ii) then
 
700
            fi(1)=fi(1)+(gsq*(1+x**2)*DLog(alpha_ii/(1-x)))/
 
701
     &           (8.*pi**2*(1-x))
 
702
         endif
 
703
 
 
704
 
 
705
c quark-gluon splitting (i:quark, ij~:gluon)
 
706
      elseif(id1.eq.1.and.id2.eq.0) then
 
707
         fi(1)=(cf*gsq*(x**2 - L*(2 + (-2 + x)*x)
 
708
     &        +(2 + (-2 + x)*x)*dLog(mu**2/muf**2) + 
 
709
     &        2*(2 + (-2 + x)*x)*DLog(1 - x)))/(8.*pi**2*x)/ca
 
710
c     adding the alpha dependent term
 
711
         if((1d0-x).gt.alpha_ii) then
 
712
            fi(1)=fi(1)+(cf*gsq*(1+(1-x)**2)*DLog(alpha_ii/(1-x)))/
 
713
     &           (8.*pi**2*x)/ca
 
714
         endif
 
715
 
 
716
 
 
717
c gluon-quark splitting (i:gluon, ij~:quark)
 
718
      elseif(id1.eq.0.and.id2.eq.1) then
 
719
         fi(1)=(gsq*(-L + 2*(1 + L)*x - 2*(1 + L)*x**2 
 
720
     &        + (1 + 2*(-1 + x)*x)*DLog(mu**2/muf**2) + 
 
721
     &        (2 + 4*(-1 + x)*x)*DLog(1 - x)))/(16.*pi**2)/cf
 
722
c adding the alpha dependent term
 
723
         if((1d0-x).gt.alpha_ii) then
 
724
            fi(1)=fi(1)+(gsq*((1-x)**2+x**2)*DLog(alpha_ii/(1-x)))/
 
725
     &           (16.*pi**2)/cf
 
726
         endif
 
727
 
 
728
c gluon-gluon splitting (i:gluon, ij~:gluon)
 
729
      elseif(id1.eq.0.and.id2.eq.0) then
 
730
         if(scheme .eq. 'HV') then
 
731
            rs=0d0
 
732
         elseif(scheme .eq. 'DR') then
 
733
            rs=-1d0/6d0
 
734
         endif
 
735
         fi(2)=(gsq*(6*L_one**2 - 3*pi**2 + 12*rs + (22 -
 
736
     &        4*Nf/ca)*DLog(mu**2/muf**2)))/(96.*pi**2)
 
737
         fi(1)=(gsq*(-1 + x*(2 + (-1 + x)*x))*
 
738
     &        (L-DLog(mu**2/muf**2)-2*DLog(1-x)))/(4.*pi**2*x)
 
739
         fi(4)=-(gsq*((2*(L_one-DLog(mu**2/muf**2)))/(1 - x)
 
740
     &        + (4*DLog(1 - x))/(-1 + x)))/(8.*pi**2)
 
741
         fi(3)=-(gsq*((2*(L-DLog(mu**2/muf**2)))/(1 - x)
 
742
     &        + (4*DLog(1 - x))/(-1 + x)))/(8.*pi**2)
 
743
c adding the alpha dependent term
 
744
         if((1d0-x).gt.alpha_ii) then
 
745
            fi(1)=fi(1)+(gsq*(-1+(1-x)*x)**2*DLog(alpha_ii/(1-x)))/
 
746
     &           (4.*pi**2*(1-x)*x)
 
747
         endif
 
748
      endif
 
749
      end
 
750
 
 
751
 
 
752
*
 
753
* dilog64.F,v 1.1.1.1 1996/04/01 15:02:05 mclareni
 
754
*
 
755
* Revision 1.1.1.1  1996/04/01 15:02:05  mclareni
 
756
* Mathlib gen
 
757
*
 
758
*
 
759
      FUNCTION DDILOG(X)
 
760
*
 
761
* imp64.inc,v 1.1.1.1 1996/04/01 15:02:59 mclareni Exp
 
762
*
 
763
* Revision 1.1.1.1  1996/04/01 15:02:59  mclareni
 
764
* Mathlib gen
 
765
*
 
766
*
 
767
* imp64.inc
 
768
*
 
769
      IMPLICIT DOUBLE PRECISION (A-H,O-Z)
 
770
      DIMENSION C(0:19)
 
771
      PARAMETER (Z1 = 1, HF = Z1/2)
 
772
      PARAMETER (PI = 3.14159 26535 89793 24D0)
 
773
      PARAMETER (PI3 = PI**2/3, PI6 = PI**2/6, PI12 = PI**2/12)
 
774
      DATA C( 0) / 0.42996 69356 08136 97D0/
 
775
      DATA C( 1) / 0.40975 98753 30771 05D0/
 
776
      DATA C( 2) /-0.01858 84366 50145 92D0/
 
777
      DATA C( 3) / 0.00145 75108 40622 68D0/
 
778
      DATA C( 4) /-0.00014 30418 44423 40D0/
 
779
      DATA C( 5) / 0.00001 58841 55418 80D0/
 
780
      DATA C( 6) /-0.00000 19078 49593 87D0/
 
781
      DATA C( 7) / 0.00000 02419 51808 54D0/
 
782
      DATA C( 8) /-0.00000 00319 33412 74D0/
 
783
      DATA C( 9) / 0.00000 00043 45450 63D0/
 
784
      DATA C(10) /-0.00000 00006 05784 80D0/
 
785
      DATA C(11) / 0.00000 00000 86120 98D0/
 
786
      DATA C(12) /-0.00000 00000 12443 32D0/
 
787
      DATA C(13) / 0.00000 00000 01822 56D0/
 
788
      DATA C(14) /-0.00000 00000 00270 07D0/
 
789
      DATA C(15) / 0.00000 00000 00040 42D0/
 
790
      DATA C(16) /-0.00000 00000 00006 10D0/
 
791
      DATA C(17) / 0.00000 00000 00000 93D0/
 
792
      DATA C(18) /-0.00000 00000 00000 14D0/
 
793
      DATA C(19) /+0.00000 00000 00000 02D0/
 
794
      IF(X .EQ. 1) THEN
 
795
       H=PI6
 
796
      ELSEIF(X .EQ. -1) THEN
 
797
       H=-PI12
 
798
      ELSE
 
799
       T=-X
 
800
       IF(T .LE. -2) THEN
 
801
        Y=-1/(1+T)
 
802
        S=1
 
803
        A=-PI3+HF*(LOG(-T)**2-LOG(1+1/T)**2)
 
804
       ELSEIF(T .LT. -1) THEN
 
805
        Y=-1-T
 
806
        S=-1
 
807
        A=LOG(-T)
 
808
        A=-PI6+A*(A+LOG(1+1/T))
 
809
       ELSE IF(T .LE. -HF) THEN
 
810
        Y=-(1+T)/T
 
811
        S=1
 
812
        A=LOG(-T)
 
813
        A=-PI6+A*(-HF*A+LOG(1+T))
 
814
       ELSE IF(T .LT. 0) THEN
 
815
        Y=-T/(1+T)
 
816
        S=-1
 
817
        A=HF*LOG(1+T)**2
 
818
       ELSE IF(T .LE. 1) THEN
 
819
        Y=T
 
820
        S=1
 
821
        A=0
 
822
       ELSE
 
823
        Y=1/T
 
824
        S=-1
 
825
        A=PI6+HF*LOG(T)**2
 
826
       ENDIF
 
827
       H=Y+Y-1
 
828
       ALFA=H+H
 
829
       B1=0
 
830
       B2=0
 
831
       DO 1 I = 19,0,-1
 
832
       B0=C(I)+ALFA*B1-B2
 
833
       B2=B1
 
834
    1  B1=B0
 
835
       H=-(S*(B0-H*B2)+A)
 
836
      ENDIF
 
837
      DDILOG=H
 
838
      RETURN
 
839
      END
 
840
 
 
841
 
 
842
 
 
843
 
 
844
 
 
845