Files
EVENT2/event2_03.f

3723 lines
139 KiB
FortranFixed

PROGRAM MAIN
IMPLICIT NONE
INTEGER NFL,NEV
DOUBLE PRECISION EM
COMMON /PARAMS/ NFL,NEV,EM
EXTERNAL DEMO
CALL READCARD
CALL DEMOIN
CALL EVENT2(NEV,EM,NFL,DEMO)
CALL DEMOUT(NEV)
END PROGRAM
C-----------------------------------------------------------------------
SUBROUTINE EVENT2(NEV,EM,NFL,USER)
IMPLICIT NONE
C---CALCULATE E+E- EVENT FEATURES TO NEXT-TO-LEADING ORDER
C ACCORDING TO THE METHOD OF CATANI AND SEYMOUR PLB378 (1996) 287
C
C VERSION 0.0 - 18th January 1996
C VERSION 0.1 - 26th February 1996 - bug fix in event orientation
C VERSION 0.2 - 15th March 1996 - removed need for Lorentz boosts
C VERSION 0.3 - 10th November 1997 - improved numerical convergence
C and safety against arithmetic errors
C - added CUTUP variable
C VERSION 0.4 - 5th May 2026 - separated hist ouput
C - added runcard input
C - allowed different bin sizes
C - seeds can now be externally set
C - added log-binning capability
C VERSION 0.5 - 11th November 2026 - Added additional shapes from EERAD3v2
C
C - NEV IS THE NUMBER OF EVENTS TO GENERATE
C - EM IS THE TOTAL CENTRE-OF-MASS ENERGY
C - NFL IS THE NUMBER OF FLAVOURS
C - USER IS THE NAME OF ROUTINE TO ANALYSE THE EVENTS
C IT TAKES FIVE ARGUMENTS:
C SUBROUTINE USER(N,NA,ITYPE,P,WEIGHT)
C N = THE NUMBER OF PARTONS
C NA = THE ORDER IN ALPHA
C ITYPE = THE TYPE: 0=TREE LEVEL, 1=SUBTRACTION, 2=FINITE VIRTUAL
C P(4,7) = THEIR MOMENTA (P(1-4,I) IS 4-MOMENTUM OF PARTICLE I,
C IN ORDER Q,QBAR, Q,QBAR,G, Q,QBAR,G,G OR Q',Q,Q'BAR,QBAR
C P(1-4,5) IS TOTAL 4-MOM OF THE N PARTICLES,
C P(1-4,6/7) IS THE 4-MOM OF THE ELECTRON/POSITRON)
C WEIGHT = THE WEIGHT IN THE INTEGRAL
C IT IS ALSO CALLED AT THE END OF EACH FULL EVENT WITH N=0
C A SIMPLE EXAMPLE (CALLED DEMO) IS GIVEN BELOW
C
C IT IS IMPORTANT TO THINK ABOUT THE EFFICIENCY OF THE USER ROUTINE,
C AS IT IS CALLED 17 TIMES PER EVENT
C (THIS IS 1 4-PARTON CALL, 12 3-PARTON CALLS AND 4 2-PARTON CALLS)
C
INTEGER NEV,NFL,NPERM3,NPERM4,NU,ND,I,J,K
LOGICAL KEEP
PARAMETER (NPERM3=2,NPERM4=10)
DOUBLE PRECISION EM,WTWO,WTHR,WFOR,JTWO,JTHR,JFOR,JTMP,
$ MTWO,MTHR,MFOR,VTWO,VTHR,STHR(NPERM3),SFOR(NPERM4),WEIGHT,
$ ZERO,ONE,P(4,7),Q(4,7,NPERM4),NRM,QD,QU,AEM,SUBS(6,NPERM4)
PARAMETER (ZERO=0,ONE=1)
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
INTEGER NPOW1,NPOW2
DOUBLE PRECISION XPOW1,XPOW2,COSP,COSM,COSZ
COMMON /SAMCOM/ XPOW1,XPOW2,COSP,COSM,COSZ,NPOW1,NPOW2
DOUBLE PRECISION CFSUB,CASUB,TFSUB,GGSUB,QQSUB,QPSUB
COMMON /SUBCOM/ CFSUB,CASUB,TFSUB,GGSUB,QQSUB,QPSUB
EXTERNAL USER
CALL PRINTHEADER
WRITE (*,'(A,I10)')' NEV=',NEV
C---INITIALIZE CONSTANTS
PI=ATAN(ONE)*4
PISQ=PI**2
HF=0.5
CA=3
CF=(CA**2-1)/(2*CA)
TR=HF
NF=NFL
ONF=1
IF (NF.NE.0) ONF=ONE/NF
ND=INT((NF+1)/2)
NU=INT(NF/2)
QD=-ONE/3
QU=QD+1
CQ=ND*QD**2+NU*QU**2
AEM=ONE/128
FPAL2=(4*PI*AEM)**2
C---METYPE IS 0 FOR ERT, 1 FOR LEIDEN AND 2 FOR GIELE-GLOVER
C (CROSS-SECTION NORMALIZATION IS DIFFERENT IN THE DIFFERENT CASES.
C FOR ERT, 2-PARTON CROSS-SECTION IS 1, FOR THE OTHERS IT IS THE
C BORN CROSS-SECTION FOR E+E- --> QQBAR IN NANOBARNS.)
METYPE=1
IF (METYPE.EQ.0) THEN
NRM=16*PI*EM**2
ELSE
NRM=389385
ENDIF
C---PARAMETERS RELATED TO IMPORTANCE SAMPLING
NPOW1=2
NPOW2=2
XPOW1=1-ONE/NPOW1
XPOW2=1-ONE/NPOW2
COSP=1
COSM=1
COSZ=0
C---START MAIN LOOP
DO I=1,NEV
IF (MOD(I,100 000).EQ.1) CALL RANGEN(-I,SFOR)
C---GENERATE A TWO-PARTON STATE
CALL GENTWO(EM,P,WTWO,*1000)
C---CALCULATE THE JACOBIAN FACTOR
CALL JACTWO(P,JTWO)
C---EVALUATE THE TWO-PARTON TREE-LEVEL MATRIX ELEMENT
CALL MATTWO(P,MTWO)
C---GIVE IT TO THE USER
WEIGHT=NRM*MTWO*WTWO/JTWO/NEV
CALL USER(2,0,0,P,WEIGHT)
IF (CUTUP.GE.1) THEN
C---EVALUATE THE TWO-PARTON ONE-LOOP MATRIX ELEMENT
CALL VIRTWO(P,VTWO)
C---GIVE IT TO THE USER
WEIGHT=NRM*VTWO*WTWO/JTWO/NEV
CALL USER(2,1,2,P,WEIGHT)
ENDIF
C---GENERATE A THREE-PARTON STATE
KEEP=.FALSE.
CALL GENTHR(P,WTHR,KEEP,*1000)
C---CALCULATE THE JACOBIAN FACTOR AND SUBTRACTION CONFIGURATIONS
JTHR=0
DO J=1,NPERM3
CALL SUBTHR(J,P,Q(1,1,J),STHR(J),JTMP,*1000)
JTHR=JTHR+JTMP
ENDDO
IF (KEEP) THEN
C---EVALUATE THE THREE-PARTON TREE-LEVEL MATRIX ELEMENT
CALL MATTHR(P,MTHR)
C---GIVE IT TO THE USER
WEIGHT=NRM*MTHR*WTWO*WTHR/JTHR/NEV
CALL USER(3,1,0,P,WEIGHT)
C---GIVE THE SUBTRACTION CONFIGURATIONS TO THE USER
DO J=1,NPERM3
WEIGHT=-NRM*STHR(J)*WTWO*WTHR/JTHR/NEV
CALL USER(2,1,1,Q(1,1,J),WEIGHT)
ENDDO
C---EVALUATE THE THREE-PARTON ONE-LOOP MATRIX ELEMENT
CALL VIRTHR(P,VTHR)
C---GIVE IT TO THE USER
WEIGHT=NRM*VTHR*WTWO*WTHR/JTHR/NEV
CALL USER(3,2,2,P,WEIGHT)
ENDIF
C---GENERATE A FOUR-PARTON STATE
CALL GENFOR(P,WFOR,KEEP,*1000)
C---CALCULATE THE JACOBIAN FACTOR AND SUBTRACTION CONFIGURATIONS
JFOR=0
DO J=1,NPERM4
CALL SUBFOR(J,P,Q(1,1,J),SFOR(J),JTMP,KEEP,*1000)
JFOR=JFOR+JTMP
SUBS(1,J)=CFSUB
SUBS(2,J)=CASUB
SUBS(3,J)=TFSUB
SUBS(4,J)=GGSUB
SUBS(5,J)=QQSUB
SUBS(6,J)=QPSUB
ENDDO
IF (KEEP) THEN
C---EVALUATE THE FOUR-PARTON TREE-LEVEL MATRIX ELEMENT
CALL MATFOR(P,MFOR)
C---GIVE IT TO THE USER
WEIGHT=NRM*MFOR*WTWO*WTHR*WFOR/JFOR/NEV
CALL USER(4,2,0,P,WEIGHT)
C---GIVE THE SUBTRACTION CONFIGURATIONS TO THE USER
DO J=1,NPERM4
CFSUB=SUBS(1,J)
CASUB=SUBS(2,J)
TFSUB=SUBS(3,J)
GGSUB=SUBS(4,J)
QQSUB=SUBS(5,J)
QPSUB=SUBS(6,J)
WEIGHT=-NRM*SFOR(J)*WTWO*WTHR*WFOR/JFOR/NEV
CALL USER(3,2,1,Q(1,1,J),WEIGHT)
ENDDO
ENDIF
C---TELL THE USER THAT THE EVENT IS COMPLETE
1000 CALL USER(0,0,0,P,ZERO)
ENDDO
END
C-----------------------------------------------------------------------
SUBROUTINE PRINTHEADER
IMPLICIT NONE
C---PRINT OPENING MESSAGE
WRITE (*,'(/2A)') ' This is EVENT2, a program for calculating',
$ ' jet quantities'
WRITE (*,'(2A)') ' in e+e- annihilation to next-to-leading',
$ ' order in alpha_s'
WRITE (*,'(A)') ' If you use this program, please reference:'
WRITE (*,'(2A)') ' S.Catani & M.H.Seymour,',
$ ' Phys. Lett. B378 (1996) 287.'
WRITE (*,'(/A)') ' Written by Mike Seymour, January 1996'
WRITE (*,'(A)') ' Edited by Giorgio Chiurato, April 2026'
WRITE (*,'(A/)') ' Version 0.5, November 2026'
END
C-----------------------------------------------------------------------
SUBROUTINE READCARD
implicit none
integer :: stat,n,nl,i,iline,ichar,Mline
parameter (Mline=200)
character(3) :: flag(1:5)
character(40) :: val(1:5)
character(20) :: fname
character(5) :: RID
character(72) :: line
character(12) :: keys(20),settings(20)
character(12) :: bkey
logical fexists
INTEGER NFL,NEV
DOUBLE PRECISION EM
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,
$ CQ,FPAL2,ONF
INTEGER K,NS,LHI
PARAMETER (NS=14)
INTEGER XBD(NS),XB(NS)
DOUBLE PRECISION XLD(NS),XHD(NS),XL(NS),XH(NS),XBS(NS)
DOUBLE PRECISION ISEEDIN(2)
CHARACTER*40 PATH
DATA XLD/
$ 0d0, 0d0,0d0,
$ 0d0, 0d0,0d0,
$ 0d0, 0d0,0d0,
$ 0d0, 0d0,0d0,
$ 0d0,-1d0/
DATA XHD/
$ 1.0d0,1.0d0,0.5d0,
$ 0.5d0,0.5d0,0.2d0,
$ 0.5d0,0.2d0,0.5d0,
$ 1.0d0,1.0d0,1.0d0,
$ 1.0d0,1.0d0/
DATA XBD/
$ 400,200,200,
$ 200,200,200,
$ 200,200,200,
$ 200,200,200,
$ 200,100/
DATA fname/'card.input'/
DATA RID /'00000'/
DATA ISEEDIN/123450,678900/
COMMON /PARAMS/ NFL,NEV,EM
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,
$ CQ,FPAL2,ONF,NF,METYPE
COMMON /GBINS/XL,XH,XB
COMMON /GBINS/LHI
COMMON /ID/ RID
common /runcard/keys,settings
PATH = './results/'
n = iargc()
nl = -1
if (n.ge.2) then
call getarg(1,flag(1))
call getarg(2,val(1))
nl = 1
endif
if (n.ge.4)then
call getarg(3,flag(2))
call getarg(4,val(2))
nl = 2
endif
if (n.ge.6)then
call getarg(5,flag(3))
call getarg(6,val(3))
nl = 3
endif
if (n.ge.8)then
call getarg(7,flag(4))
call getarg(8,val(4))
nl = 4
endif
if (n.ge.10)then
call getarg(9,flag(5))
call getarg(10,val(5))
nl = 5
endif
C TODO: need to add a proper info page and maybe change the input parameter handling.
do i=1,nl
if (flag(i).eq.'-i')then
fname = val(i)
elseif (flag(i).eq.'-o')then
PATH = val(i)
elseif (flag(i).eq.'-sa') then
read(val(i), *) ISEEDIN(1)
elseif (flag(i).eq.'-sb') then
read(val(i), *) ISEEDIN(2)
elseif (flag(i).eq.'-c') then
RID = val(i)
else
CALL PRINTHEADER
print *, 'Option ', flag(i),
$ ' not recognized.'
STOP "Exiting program..."
endif
enddo
call RANGEN(0, ISEEDIN)
call CREATEOUT(PATH)
inquire(file=fname, exist=fexists)
if (.not.fexists)then
CALL PRINTHEADER
stop 'run card ' // trim(fname) // ' not found'
endif
open(9,file=fname)
iline = 1
do
call getline(9, line, stat)
if (line.ne.'')then
ichar = index(line, "=")
if (ichar.gt.0)then
keys(iline) = line(:ichar-1)
settings(iline) = line(ichar+1:)
endif
iline = iline+1
endif
if (stat.lt.0) exit
end do
call readparm('EM ', EM, real(91.187, 8))
call readparm('CUTOFF ', CUTOFF, 1D-8)
call readparm('CUTUP ', CUTUP , 1D0)
call readmode('NF ', NFL, 5)
call readmode('NEV ', NEV, 5 000 000)
DO K=1,NS
WRITE(bkey,'(A2,I2.2)') 'XL',K
CALL READPARM(bkey, XL(K), XLD(K))
WRITE(bkey,'(A2,I2.2)') 'XH',K
CALL READPARM(bkey, XH(K), XHD(K))
WRITE(bkey,'(A2,I2.2)') 'XB',K
CALL READMODE(bkey, XB(K), XBD(K))
IF (XH(K).LE.XL(K)) THEN
PRINT *, 'Bad limits for shape ', K
STOP 'Exiting program...'
ENDIF
ENDDO
call readmode('LH ', LHI , 0)
C Close file.
close(9)
END
C-----------------------------------------------------------------------
SUBROUTINE DEMOIN
IMPLICIT NONE
CHARACTER(5) RID
LOGICAL LH
DOUBLE PRECISION CSUM,CSQR,BSUM,BSQR
INTEGER NS,I
PARAMETER (NS=14)
INTEGER XB(NS)
DOUBLE PRECISION XL(NS),XH(NS),XBS(NS)
CHARACTER*16 GNAME(NS)
DATA GNAME/
$ 'C-PARAMETER_ ','D-PARAMETER_ ','1-THRUST_ ',
$ 'T-MINOR_ ','M2-HEAVY_ ','M2-LIGHT_ ',
$ 'B-W_ ','B-N_ ','B-T_ ',
$ 'FC0_ ','FC1_ ','FC2_ ',
$ 'FC3_ ','EEC_ '/
COMMON /DEMCOM/CSUM(NS+3),CSQR(NS+3),BSUM(2,6),BSQR(2,6)
COMMON /GBINS/XL,XH,XB
COMMON /GBINS/LH
COMMON /ID/ RID
DO I=1,NS
XBS(I)=(XH(I)-XL(I))/XB(I)
ENDDO
DO I=1,NS+3
CSUM(I)=0
CSQR(I)=0
IF (I.LE.6) THEN
BSUM(1,I)=0
BSUM(2,I)=0
BSQR(1,I)=0
BSQR(2,I)=0
ENDIF
ENDDO
DO I=1,NS
CALL GBOOK1( I,TRIM(GNAME(I))//RID,XB(I),XL(I),XH(I),LH)
CALL GBOOK1( 100+I,TRIM(GNAME(I))//RID,XB(I),XL(I),XH(I),LH)
CALL GBOOK1( 200+I,TRIM(GNAME(I))//RID,XB(I),XL(I),XH(I),LH)
CALL GBOOK1(1000+I,TRIM(GNAME(I))//RID,XB(I),XL(I),XH(I),LH)
CALL GBOOK1(1100+I,TRIM(GNAME(I))//RID,XB(I),XL(I),XH(I),LH)
CALL GBOOK1(1200+I,TRIM(GNAME(I))//RID,XB(I),XL(I),XH(I),LH)
ENDDO
END
C-----------------------------------------------------------------------
SUBROUTINE DEMOUT(NEV)
IMPLICIT NONE
INTEGER NS,I,J,NEV
PARAMETER(NS=14)
DOUBLE PRECISION CSUM,CSQR,BSUM,BSQR,SF,SQR
COMMON /DEMCOM/CSUM(NS+3),CSQR(NS+3),BSUM(2,6),BSQR(2,6)
CHARACTER*10 NAME(NS+3)
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
SQR(SF)=SIGN(SQRT(ABS(SF)),SF)
DATA NAME/
$ ' sigma_0',' sigma_1',' C-PARAM',
$ ' D-PARAM',' 1-THRUST',' T-MINOR',
$ ' M2-HEAVY',' M2-LIGHT',' B-W',
$ ' B-N',' B-T',' FC0',
$ ' FC1',' FC2',' FC3',
$ 'EEC(90deg)','EEC(total)'/
SF=CSUM(1)
IF (SF.NE.0) THEN
DO I=1,NS
CALL GSCALE( I,1/SF)
CALL GSCALE( 100+I,1/SF**2)
CALL GSCALE(1000+I,1/SF)
CALL GSCALE(1100+I,1/SF**2)
ENDDO
DO I=1,NS+2
CSUM(I+1)=CSUM(I+1)/SF
CSQR(I+1)=CSQR(I+1)/SF**2
ENDDO
DO I=1,6
BSUM(1,I)=BSUM(1,I)/SF
BSQR(1,I)=BSQR(1,I)/SF**2
BSUM(2,I)=BSUM(2,I)/SF
BSQR(2,I)=BSQR(2,I)/SF**2
ENDDO
ENDIF
DO I=1,NS
CALL GOPERA( I,'*', I, 200+I,1D0,1D0)
CALL GOPERA( 100+I,'-' ,200+I, 100+I,1D0,1D0/NEV)
CALL GOPERA( 100+I,'S', 0, 100+I,1D0,0D0)
CALL GOPERA(1000+I,'*',1000+I,1200+I,1D0,1D0)
CALL GOPERA(1100+I,'-',1200+I,1100+I,1D0,1D0/NEV)
CALL GOPERA(1100+I,'S', 0,1100+I,1D0,0D0)
CALL GTOPER( I,1,1,0,100+I)
CALL GTOPER(1000+I,0,0,0,1100+I)
ENDDO
WRITE (*,'(1X,A,F15.5,A,F15.5)')
$ (NAME(I),CSUM(I),' +-',
$ SQR(CSQR(I)-CSUM(I)**2/NEV),I=1,NS+3)
WRITE (*,'(2(/A))') ' Moments of EEC function:',' m n'
WRITE (*,'(2I4,F15.5,A,F15.5)')
$ ((I-1,J-1,BSUM(I,J),' +-',SQR(BSQR(I,J)-BSUM(I,J)**2/NEV)
$ ,J=1,6),I=1,2)
END
C-----------------------------------------------------------------------
SUBROUTINE DEMO(N,NA,ITYPE,P,WEIGHT)
IMPLICIT NONE
INTEGER NS,N,NA,ITYPE,I,J,K,L,ORD
PARAMETER(NS=14)
DOUBLE PRECISION
$ P(4,7),PN(4,7),WEIGHT,DOT,OS,ORS,E(7),OE(7),
$ CSUM(NS+3),CSQR(NS+3),CS(NS+3),BSUM(2,6),BSQR(2,6),
$ BS(2,6),C,D,SPAR,APAR,PLAN,TTT,TAU,TMAJ,TMIN,OPAR,EM2H,
$ EM2L,EM2D,BMAX,BMIN,BTOT,BDIF,FC(4),BKS(4),SH(NS),
$ XL(NS),XH(NS),XCOS(6),XEEC(6),BSEV(2,6),EECW,EECT
DOUBLE PRECISION CFSUB,CASUB,TFSUB,GGSUB,QQSUB,QPSUB
INTEGER NPR,XB(NS)
LOGICAL LH
COMMON /SUBCOM/ CFSUB,CASUB,TFSUB,GGSUB,QQSUB,QPSUB
COMMON /DEMCOM/CSUM,CSQR,BSUM,BSQR
COMMON /GBINS/XL,XH,XB
COMMON /GBINS/LH
DATA CS,BS/29*0/
C---FILL THE HISTOGRAMS AT THE END OF EACH EVENT
C (THIS IS SO THAT PAIRS OF LARGE POSITIVE AND NEGATIVE WEIGHTS
C GET CANCELLED BEFORE CALCULATING THE VARIANCE)
IF (N.EQ.0) THEN
DO I=0,1000,1000
DO J=1,NS
CALL GOPERA(200+I+J,'+', I+J, I+J,1D0,1D0)
CALL GOPERA(200+I+J,'*',200+I+J,200+I+J,1D0,1D0)
CALL GOPERA(200+I+J,'+',100+I+J,100+I+J,1D0,1D0)
CALL GRESET(200+I+J)
ENDDO
ENDDO
DO I=1,NS+3
CSUM(I)=CSUM(I)+CS(I)
CSQR(I)=CSQR(I)+CS(I)**2
CS(I)=0
IF (I.LE.6) THEN
BSUM(1,I)=BSUM(1,I)+BS(1,I)
BSUM(2,I)=BSUM(2,I)+BS(2,I)
BSQR(1,I)=BSQR(1,I)+BS(1,I)**2
BSQR(2,I)=BSQR(2,I)+BS(2,I)**2
BS(1,I)=0
BS(2,I)=0
ENDIF
ENDDO
RETURN
ENDIF
C---CALCULATE THE ENERGY OF EACH PARTICLE
OS=1/DOT(P,5,5)
ORS=SQRT(OS)
DO I=1,7
IF (I.LE.N.OR.I.GE.5) THEN
E(I)=DOT(P,I,5)*ORS
OE(I)=1/E(I)
ENDIF
ENDDO
C---CALCULATE THE TOTAL CROSS-SECTION
IF (NA.EQ.0) CS(1)=CS(1)+WEIGHT
IF (NA.EQ.1) CS(2)=CS(2)+WEIGHT
IF (N.LT.3) RETURN
ORD=(2-NA)*1000
c$$$C---ONLY INCLUDE ONE OF THE COLOUR PIECES IN THE ALPHA_S**2 TERMS
c$$$ IF (NA.EQ.2) WEIGHT=WEIGHT*CASUB
C---COMPUTE EVENT SHAPES USING EERAD3 CODE
C---EERAD3 NEEDS NORMALIZED MOMENTA
DO I=1,N
DO J=1,4
PN(J,I)=P(J,I)*ORS
ENDDO
ENDDO
CALL GETCD(C,D,PN,N)
CALL GETSAP(SPAR,APAR,PLAN,PN,N)
CALL GETT(TTT,TMAJ,TMIN,OPAR,EM2H,EM2L,EM2D,BMAX,BMIN,BTOT,BDIF,
$ FC(1),FC(2),FC(3),FC(4),BKS(1),BKS(2),BKS(3),BKS(4),PN,N)
TAU=1D0-TTT
SH( 1)= C; SH( 2)= D; SH( 3)= TAU
SH( 4)= TMIN; SH( 5)= EM2H; SH( 6)= EM2L
SH( 7)= BMAX; SH( 8)= BMIN; SH( 9)= BTOT
SH(10)=FC(1); SH(11)=FC(2); SH(12)=FC(3)
SH(13)=FC(4)
DO I=1,NS-1
CALL GFILLSC1(200+ORD+I,SH(I),WEIGHT)
IF (ORD.EQ.0) CS(I+2)=CS(I+2)+WEIGHT*SH(I)
ENDDO
C---EEC NEEDS A SEPARATE TREATMENT
CALL GETEEC(XCOS,XEEC,NPR,BSEV,EECW,EECT,PN,N)
DO I=1,NPR
CALL GFILLSC1(200+ORD+NS,XCOS(I),XEEC(I)*WEIGHT)
ENDDO
IF (ORD.EQ.0) THEN
CS(NS+2)=CS(NS+2)+EECW*WEIGHT
CS(NS+3)=CS(NS+3)+EECT*WEIGHT
DO K=1,2
DO L=1,6
BS(K,L)=BS(K,L)+BSEV(K,L)*WEIGHT
ENDDO
ENDDO
ENDIF
END
C-----------------------------------------------------------------------
FUNCTION DOT(P,I,J)
IMPLICIT NONE
C---RETURN THE DOT PRODUCT OF P(*,I) AND P(*,J)
INTEGER I,J
DOUBLE PRECISION DOT,P(4,7)
DOT=P(4,I)*P(4,J)-P(3,I)*P(3,J)-P(2,I)*P(2,J)-P(1,I)*P(1,J)
END
C-----------------------------------------------------------------------
SUBROUTINE GENTWO(EM,P,W,*)
IMPLICIT NONE
C---GENERATE A TWO-PARTON CONFIGURATION
C THE WEIGHT GIVES THE TOTAL VOLUME OF PHASE-SPACE
DOUBLE PRECISION EM,P(4,7),W,R(5),E,C,S,A
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
INTEGER NPOW1,NPOW2
DOUBLE PRECISION XPOW1,XPOW2,COSP,COSM,COSZ
COMMON /SAMCOM/ XPOW1,XPOW2,COSP,COSM,COSZ,NPOW1,NPOW2
C---GENERATE C=COS(THETA) ACCORDING TO COSZ+COSP*(1+C)**2+COSM*(1-C)**2
CALL RANGEN(5,R)
E=EM/2
IF (R(1)*(4*COSP+4*COSM+3*COSZ).LT.4*COSP) THEN
C=2*MAX(R(2),R(3),R(4))-1
ELSEIF (R(1)*(4*COSP+4*COSM+3*COSZ).LT.4*COSP+4*COSM) THEN
C=2*MIN(R(2),R(3),R(4))-1
ELSE
C=2*R(2)-1
ENDIF
S=1-C**2
IF (S.LT.0) CALL WARNER('GENTWO',1,*999)
S=SQRT(S)
A=2*PI*R(5)
P(1,1)= E*COS(A)*S
P(2,1)= E*SIN(A)*S
P(3,1)= E*C
P(4,1)= E
P(1,2)= -E*COS(A)*S
P(2,2)= -E*SIN(A)*S
P(3,2)= -E*C
P(4,2)= E
P(1,5)= 0
P(2,5)= 0
P(3,5)= 0
P(4,5)=2*E
P(1,6)= 0
P(2,6)= 0
P(3,6)= E
P(4,6)= E
P(1,7)= 0
P(2,7)= 0
P(3,7)= -E
P(4,7)= E
W=1/(16*PI*EM**2)
RETURN
999 RETURN 1
END
C-----------------------------------------------------------------------
SUBROUTINE GENTHR(P,W,KEEP,*)
IMPLICIT NONE
C---GENERATE A THREE-PARTON CONFIGURATION FROM A GIVEN TWO-PARTON ONE
C IF ANY DOT PRODUCTS ARE BELOW CUTOFF, EVENT IS REJECTED,
C BY JUMPING TO THE SPECIFIED LABEL
C IF ANY DOT PRODUCTS ARE BELOW CUTUP, EVENT IS MARKED BY KEEP=.TRUE.
INTEGER EMIT,OMIT
LOGICAL KEEP
DOUBLE PRECISION P(4,7),W,X(2),R(4),EMSQ,DOT,T
INTEGER I
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
INTEGER NPOW1,NPOW2
DOUBLE PRECISION XPOW1,XPOW2,COSP,COSM,COSZ
COMMON /SAMCOM/ XPOW1,XPOW2,COSP,COSM,COSZ,NPOW1,NPOW2
C---GENERATE X1,X2 VALUES
CALL RANGEN(4,R)
X(1)=1-(R(1)*R(2))**NPOW1
IF (X(1).GT.1) CALL WARNER('GENTHR',1,*999)
X(2)=2-X(1)-(1-X(1))**R(3)
C---ENFORCE INVARIANT MASS CUTOFFS
IF (1-X(1).LT.CUTOFF.OR.1-X(2).LT.CUTOFF.OR.X(1)+X(2)-1.LT.CUTOFF)
$ RETURN 1
IF (1-X(1).LT.CUTUP.OR.1-X(2).LT.CUTUP.OR.X(1)+X(2)-1.LT.CUTUP)
$ KEEP=.TRUE.
C---CHOOSE WHICH ONE EMITTED
EMIT=INT(R(4)*2)+1
OMIT=3-EMIT
C---GENERATE THEIR MOMENTA
CALL GENDIP(P,EMIT,OMIT,3,X,*999)
C---NOW SWAP EMITTER AND 3 HALF THE TIME
IF (MOD(INT(4*R(4)),2).EQ.1) THEN
DO I=1,4
T=P(I,EMIT)
P(I,EMIT)=P(I,3)
P(I,3)=T
ENDDO
ENDIF
C---CALCULATE WEIGHT
EMSQ=DOT(P,5,5)
W=HF*EMSQ/(16*PISQ)
RETURN
999 RETURN 1
END
C-----------------------------------------------------------------------
SUBROUTINE GENFOR(P,W,KEEP,*)
IMPLICIT NONE
C---GENERATE A FOUR-BODY CONFIGURATION FROM A GIVEN THREE-BODY ONE
C IF ANY DOT PRODUCTS ARE BELOW CUTOFF, EVENT IS REJECTED,
C BY JUMPING TO THE SPECIFIED LABEL
C IF ANY DOT PRODUCTS ARE BELOW CUTUP, EVENT IS MARKED BY KEEP=.TRUE.
INTEGER I,J,EMIT,OMIT
LOGICAL KEEP
DOUBLE PRECISION P(4,7),W,X(2),R(6),T,EMSQ,DOT
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
INTEGER NPOW1,NPOW2
DOUBLE PRECISION XPOW1,XPOW2,COSP,COSM,COSZ
COMMON /SAMCOM/ XPOW1,XPOW2,COSP,COSM,COSZ,NPOW1,NPOW2
C---GENERATE X1,X2 VALUES
CALL RANGEN(6,R)
X(1)=1-(R(1)*R(2))**NPOW2
IF (X(1).GT.1) CALL WARNER('GENFOR',1,*999)
X(2)=2-X(1)-(1-X(1))**R(3)
C---ENFORCE INVARIANT MASS CUTOFFS
W=0
IF (1-X(1).LT.CUTOFF.OR.1-X(2).LT.CUTOFF.OR.X(1)+X(2)-1.LT.CUTOFF)
$ RETURN 1
C---CHOOSE WHICH ONE TO SPLIT UNIFORMLY
EMIT=INT(R(4)*3)+1
C---AND WHICH OF THE OTHERS TO BALANCE ITS MOMENTUM WITH
OMIT=INT(R(5)*2)+1
IF (OMIT.EQ.EMIT) OMIT=3
C---GENERATE THEIR MOMENTA
CALL GENDIP(P,EMIT,OMIT,4,X,*999)
C---HALF THE TIME, SWAP PARTICLES 3 AND 4 SO THEY ARE SYMMETRIC
IF (R(6).GT.0.5) THEN
DO I=1,4
T=P(I,3)
P(I,3)=P(I,4)
P(I,4)=T
ENDDO
ENDIF
C---REJECT THE EVENT IF ANY PAIR MASSES ARE BELOW CUTOFF*Q**2
EMSQ=DOT(P,5,5)
DO I=1,3
DO J=I+1,4
IF (2*DOT(P,I,J).LT.CUTOFF*EMSQ) RETURN 1
IF (2*DOT(P,I,J).LT.CUTUP*EMSQ) KEEP=.TRUE.
ENDDO
ENDDO
C---CALCULATE WEIGHT (NOTE: THIS IS NORMALIZED TO THE TOTAL CMF MASS,
C RATHER THAN THE SUBSYSTEM MASS. THE EXTRA FACTOR GETS INSERTED IN
C THE JACOBIAN FACTOR CALCULATED IN SUBFOR)
W=HF*EMSQ/(16*PISQ)
RETURN
999 RETURN 1
END
C-----------------------------------------------------------------------
SUBROUTINE GENDIP(P,EMIT,OMIT,THRD,X,*)
IMPLICIT NONE
C---GENERATE A 2->3 DIPOLE EMISSION
DOUBLE PRECISION P(4,7),X(2),R(1),Q(4,2),PTDQ,C(4),D(4)
INTEGER EMIT,OMIT,THRD,I
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
CALL RANGEN(1,R)
PTDQ=(X(1)+X(2)-1)*(1-X(1))*(1-X(2))/X(1)**2
IF (PTDQ.LT.0) CALL WARNER('GENDIP',1,*999)
PTDQ=SQRT(PTDQ)
CALL GTPERP(PTDQ,P,EMIT,OMIT,6,C,D,*999)
DO I=1,4
Q(I,1)=X(1)*P(I,OMIT)
Q(I,2)=(1-(1-X(2))/X(1))*P(I,EMIT)
$ +(1-X(1))*(1-X(2))/X(1)*P(I,OMIT)
$ +COS(R(1)*2*PI)*C(I)+SIN(R(1)*2*PI)*D(I)
ENDDO
DO I=1,4
P(I,THRD)=P(I,EMIT)+P(I,OMIT)-Q(I,1)-Q(I,2)
P(I,OMIT)=Q(I,1)
P(I,EMIT)=Q(I,2)
ENDDO
RETURN
999 RETURN 1
END
C-----------------------------------------------------------------------
SUBROUTINE GTPERP(PTDQ,P,I,J,K,C,D,*)
IMPLICIT NONE
C---FIND THE VECTORS PERPENDICULAR TO P(I) AND P(J)
C C AND D ARE PURELY SPACE-LIKE VECTORS IN THE P(I)+P(J) CMF,
C WITH C IN THE SAME PLANE AS P(K) AND D PERPENDICULAR TO IT,
C BOTH HAVING LENGTH PTDQ*SQRT(2*DOT(P,I,J))
DOUBLE PRECISION PTDQ,P(4,7),C(4),D(4),PTF,DIJ,DIK,DJK,DOT,EPS4
INTEGER I,J,K,L
DIJ=DOT(P,I,J)
DIK=DOT(P,I,K)
DJK=DOT(P,J,K)
IF (DIK.LE.0.OR.DJK.LE.0) CALL WARNER('GTPERP',1,*999)
PTF=PTDQ/SQRT(DIK*DJK)
DO L=1,4
C(L)=PTF*(DIJ*P(L,K)-DJK*P(L,I)-DIK*P(L,J))
ENDDO
DO L=1,4
D(L)=EPS4(L,P(1,I),P(1,J),C)/DIJ
ENDDO
RETURN
999 RETURN 1
END
C-----------------------------------------------------------------------
FUNCTION EPS4(I,A,B,C)
IMPLICIT NONE
DOUBLE PRECISION EPS4,EPS3,A(4),B(4),C(4),AA(3),BB(3),CC(3)
INTEGER I,J,K,S(4)
DATA S/+1,-1,+1,+1/
J=1
DO K=1,3
IF (I.EQ.J) J=J+1
AA(K)=A(J)
BB(K)=B(J)
CC(K)=C(J)
J=J+1
ENDDO
EPS4=0
DO J=1,3
EPS4=EPS4+CC(J)*EPS3(J,AA,BB)
ENDDO
EPS4=S(I)*EPS4
END
C-----------------------------------------------------------------------
FUNCTION EPS3(I,A,B)
IMPLICIT NONE
DOUBLE PRECISION EPS3,A(3),B(3),AA(2),BB(2)
INTEGER I,J,K,S(3)
DATA S/+1,-1,+1/
J=1
DO K=1,2
IF (I.EQ.J) J=J+1
AA(K)=A(J)
BB(K)=B(J)
J=J+1
ENDDO
EPS3=S(I)*(AA(1)*BB(2)-AA(2)*BB(1))
END
C-----------------------------------------------------------------------
SUBROUTINE JACTWO(P,J)
IMPLICIT NONE
C---CALCULATE THE TWO-PARTON JACOBIAN FACTOR
DOUBLE PRECISION P(4,7),J,CP,CM,DOT
INTEGER NPOW1,NPOW2
DOUBLE PRECISION XPOW1,XPOW2,COSP,COSM,COSZ
COMMON /SAMCOM/ XPOW1,XPOW2,COSP,COSM,COSZ,NPOW1,NPOW2
CP=DOT(P,1,7)*DOT(P,5,5)/(DOT(P,1,5)*DOT(P,7,5))
CM=DOT(P,1,6)*DOT(P,5,5)/(DOT(P,1,5)*DOT(P,6,5))
J=(COSZ+COSP*CP**2+COSM*CM**2)*3/(3*COSZ+4*COSP+4*COSM)
END
C-----------------------------------------------------------------------
SUBROUTINE MATTWO(P,M)
IMPLICIT NONE
C---EVALUATE THE TWO-PARTON MATRIX ELEMENT SQUARED FOR THE GIVEN
C CONFIGURATION. USING ERT NORMALIZATION, THIS IS JUST UNITY.
DOUBLE PRECISION P(4,7),M,EMSQ,DOT
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
IF (METYPE.EQ.0) THEN
M=1
ELSEIF (METYPE.EQ.1) THEN
EMSQ=DOT(P,5,5)
M=2*(-8*DOT(P,1,6)*DOT(P,2,6))+EMSQ/2*(4*EMSQ)
C---INCLUDE EXTERNAL FACTORS
M=M/4/EMSQ
M=M*FPAL2*CA*CQ*4/EMSQ
ELSEIF (METYPE.EQ.2) THEN
CALL CONVERT(P)
CALL SETUP
CALL SFMEE(2,0,M)
ELSE
STOP 'UNKNOWN MATRIX-ELEMENT TYPE IN MATTWO!'
ENDIF
END
C-----------------------------------------------------------------------
SUBROUTINE MATTHR(P,M)
IMPLICIT NONE
C---EVALUATE THE THREE-PARTON MATRIX ELEMENT SQUARED FOR THE GIVEN
C CONFIGURATION. INCLUDES COLOUR FACTORS, BUT NOT ALPHA_S/2PI.
DOUBLE PRECISION P(4,7),M,EMSQ,E1,E2,S13,S23,DOT,K1,K2,K3
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
IF (METYPE.EQ.0) THEN
EMSQ=DOT(P,5,5)
S13=2*DOT(P,1,3)
S23=2*DOT(P,2,3)
E1=EMSQ-S23
E2=EMSQ-S13
M=CF*16*PISQ*(E1**2+E2**2)/(EMSQ*S13*S23)
ELSEIF (METYPE.EQ.1) THEN
EMSQ=DOT(P,5,5)
S13=2*DOT(P,1,3)
S23=2*DOT(P,2,3)
E1=EMSQ-S23
E2=EMSQ-S13
K1=2*DOT(P,1,6)
K2=2*DOT(P,2,6)
K3=2*DOT(P,3,6)
M=CF*16*PISQ/(S13*S23)*(
$ 2*(2*(K1**2*S23+K2**2*S13
$ -K1*K2*(E1+E2)-K2*K3*E2-K3*K1*E1))
$ +EMSQ/2*(4*(E1**2+E2**2)))
C---INCLUDE EXTERNAL FACTORS
M=M/4/EMSQ
M=M*FPAL2*CA*CQ*4/EMSQ
ELSEIF (METYPE.EQ.2) THEN
CALL CONVERT(P)
CALL SETUP
CALL SFMEE(3,0,M)
ELSE
STOP 'UNKNOWN MATRIX-ELEMENT TYPE IN MATTHR!'
ENDIF
END
C-----------------------------------------------------------------------
SUBROUTINE CONTHR(P,V,VV,M)
IMPLICIT NONE
C---EVALUATE THE CONTRACTION OF THE THREE-PARTON MATRIX ELEMENT SQUARED
C FOR THE GIVEN CONFIGURATION WITH THE VECTOR V. IT IS ASSUMED THAT
C V IS PERPENDICULAR TO THE GLUON, V.P3.EQ.0, AND THAT V.V.NE.0 .
C THE NORMALIZATION IS SUCH THAT THE AVERAGE OVER V'S AZIMUTH AROUND
C P3 IS EQUAL TO HALF OF MATTHR
INTEGER I,J
DOUBLE PRECISION P(4,7),V(4),M,DOT,VDOT,EMSQ,OMSQ,VV,Y1,Y2,L1,L2,
$ DOTS,T1,T2,T3,T4,T
C---EERAD COMMON BLOCKS
DOUBLE PRECISION CZUR,CZUL,CZDR,CZDL,CZLR,CZLL,CZNR,CZNL,
$ CGUR,CGUL,CGDR,CGDL,CGLR,CGLL,CGNR,CGNL,
$ W,EM,SW2,RMZ,RGZ,
$ CGGVV,CGZVV,CZZVV,CVV,CGGAA,CGZAA,CZZAA,CAA
INTEGER NUTF,NDTF,ICON
COMMON /ZCUP/CZUR,CZUL,CZDR,CZDL,CZLR,CZLL,CZNR,CZNL
COMMON /GCUP/CGUR,CGUL,CGDR,CGDL,CGLR,CGLL,CGNR,CGNL
COMMON /GENERA/ W,EM,SW2,RMZ,RGZ,NUTF,NDTF,ICON
C---END EERAD COMMON BLOCKS
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
VDOT(I)=P(4,I)*V(4)-P(3,I)*V(3)-P(2,I)*V(2)-P(1,I)*V(1)
IF (METYPE.EQ.0) THEN
EMSQ=DOT(P,5,5)
OMSQ=1/EMSQ
Y1=2*DOT(P,2,3)
Y2=2*DOT(P,1,3)
T=CF*16*PISQ/(Y1*Y2)**2
M=-T*(2*(VDOT(1)*Y1-VDOT(2)*Y2)**2/VV
$ -HF*(Y1**2+Y2**2)*Y1*Y2*OMSQ)
ELSEIF (METYPE.EQ.1.OR.METYPE.EQ.2) THEN
EMSQ=DOT(P,5,5)
OMSQ=1/EMSQ
Y1=2*DOT(P,2,3)
Y2=2*DOT(P,1,3)
L1=2*DOT(P,1,7)
L2=2*DOT(P,2,7)
DOTS=1/(VV*(Y1+Y2)**2)
C---INCLUDE COUPLING STRENGTHS
IF (METYPE.EQ.1) THEN
CVV=CQ*FPAL2
CAA=0
ELSE
cggvv=nutf*0.25*(cgur**2+cgul**2)*(cglr**2+cgll**2)
$ +ndtf*0.25*(cgdr**2+cgdl**2)*(cglr**2+cgll**2)
cggaa=nutf*0.25*(cgur**2-cgul**2)*(cglr**2-cgll**2)
$ +ndtf*0.25*(cgdr**2-cgdl**2)*(cglr**2-cgll**2)
cgzvv=nutf*0.5*(cgur*czur+cgul*czul)*(cglr*czlr+cgll*czll)
$ *emsq*(emsq-rmz**2)/((emsq-rmz**2)**2+(rgz*rmz)**2)
$ +ndtf*0.5*(cgdr*czdr+cgdl*czdl)*(cglr*czlr+cgll*czll)
$ *emsq*(emsq-rmz**2)/((emsq-rmz**2)**2+(rgz*rmz)**2)
cgzaa=nutf*0.5*(cgur*czur-cgul*czul)*(cglr*czlr-cgll*czll)
$ *emsq*(emsq-rmz**2)/((emsq-rmz**2)**2+(rgz*rmz)**2)
$ +ndtf*0.5*(cgdr*czdr-cgdl*czdl)*(cglr*czlr-cgll*czll)
$ *emsq*(emsq-rmz**2)/((emsq-rmz**2)**2+(rgz*rmz)**2)
czzvv=nutf*0.25*(czur**2+czul**2)*(czlr**2+czll**2)
$ *emsq**2/((emsq-rmz**2)**2+(rgz*rmz)**2)
$ +ndtf*0.25*(czdr**2+czdl**2)*(czlr**2+czll**2)
$ *emsq**2/((emsq-rmz**2)**2+(rgz*rmz)**2)
czzaa=nutf*0.25*(czur**2-czul**2)*(czlr**2-czll**2)
$ *emsq**2/((emsq-rmz**2)**2+(rgz*rmz)**2)
$ +ndtf*0.25*(czdr**2-czdl**2)*(czlr**2-czll**2)
$ *emsq**2/((emsq-rmz**2)**2+(rgz*rmz)**2)
if (icon.eq.1) then
cvv=cggvv
caa=cggaa
elseif (icon.eq.2) then
cvv=cgzvv
caa=cgzaa
elseif (icon.eq.3) then
cvv=czzvv
caa=czzaa
else
cvv=cggvv+cgzvv+czzvv
caa=cggaa+cgzaa+czzaa
endif
cvv=cvv*em**4
caa=caa*em**4
ENDIF
C---THE VECTOR-VECTOR PART
T=CF*16*PISQ*CA*CVV/(Y1*Y2)**2
T1=T*4*(Y1**2*(L2**2+(EMSQ-L2)**2)+Y2**2*(L1**2+(EMSQ-L1)**2)
$ +2*Y1*Y2*(L1*EMSQ+L2*EMSQ-2*L1*L2))*OMSQ**2*DOTS
T2=T*4*(Y2*(EMSQ-2*L1)-Y1*(EMSQ-2*L2))*Y1*Y2*OMSQ**2*DOTS
T3=T*8*(Y1*Y2*OMSQ)**2*DOTS
T4=T*((EMSQ-Y1-L1-L2)**2+(EMSQ-Y2-L1-L2)**2)
$ *Y1*Y2*OMSQ
C---THE AXIAL-AXIAL PART
T=CF*16*PISQ*CA*CAA/(Y1*Y2)**2
T1=T1+T*4*(Y1*(EMSQ-2*L2)-Y2*(EMSQ-2*L1))*(Y1+Y2)*OMSQ*DOTS
T2=T2-T*4*(Y1+Y2)*Y1*Y2*OMSQ*DOTS
T3=T3
T4=T4-T*(Y1+Y2+2*(L1+L2-EMSQ))*(Y1-Y2)*Y1*Y2*OMSQ
M=-T1*(VDOT(1)*Y1-VDOT(2)*Y2)**2
$ -T2*2*(VDOT(1)*Y1-VDOT(2)*Y2)*
$ (VDOT(7)*(Y2+Y1-EMSQ+L1+L2)-(EMSQ-L1-L2)*VDOT(6))
$ -T3*(VDOT(7)*(Y2+Y1-EMSQ+L1+L2)-(EMSQ-L1-L2)*VDOT(6))**2
$ +T4
ELSE
STOP 'UNKNOWN MATRIX-ELEMENT TYPE IN CONTHR!'
ENDIF
END
C-----------------------------------------------------------------------
SUBROUTINE MATFOR(P,M)
IMPLICIT NONE
C---EVALUATE THE FOUR-PARTON MATRIX ELEMENT SQUARED FOR THE GIVEN
C CONFIGURATION. INCLUDES COLOUR FACTORS, BUT NOT (ALPHA_S/2PI)**2.
DOUBLE PRECISION P(4,7),M,ERTA,ERTB,ERTC,ERTD,ERTE,
$ LEIA,LEIB,LEIC,LEID,LEIE,
$ A,B,C,DS,DD,E,EMSQ,DOT,T
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
DOUBLE PRECISION CFSUB,CASUB,TFSUB,GGSUB,QQSUB,QPSUB
COMMON /SUBCOM/ CFSUB,CASUB,TFSUB,GGSUB,QQSUB,QPSUB
C---EERAD COMMON BLOCKS
INTEGER IPS
COMMON /PERM/IPS
C---END EERAD COMMON BLOCKS
IF (METYPE.EQ.0) THEN
A=HF*(
$ ERTA(P,1,2,3,4)+ERTA(P,2,1,3,4)+ERTA(P,1,2,4,3)+ERTA(P,2,1,4,3))
B=HF*(
$ ERTB(P,1,2,3,4)+ERTB(P,2,1,3,4)+ERTB(P,1,2,4,3)+ERTB(P,2,1,4,3))
C=HF*(
$ ERTC(P,1,2,3,4)+ERTC(P,2,1,3,4)+ERTC(P,1,2,4,3)+ERTC(P,2,1,4,3))
DD=HF*(
$ ERTD(P,1,2,3,4)+ERTD(P,2,1,4,3)+ERTD(P,3,4,1,2)+ERTD(P,4,3,2,1))
DS=HF*HF*(
$ ERTD(P,2,1,3,4)+ERTD(P,1,2,4,3)+ERTD(P,3,4,2,1)+ERTD(P,4,3,1,2))
E=HF*HF*(
$ ERTE(P,1,2,3,4)+ERTE(P,2,1,4,3)+ERTE(P,3,4,1,2)+ERTE(P,4,3,2,1)+
$ ERTE(P,2,1,3,4)+ERTE(P,1,2,4,3)+ERTE(P,3,4,2,1)+ERTE(P,4,3,1,2))
CFSUB=A+B+E
CASUB=C-(B+E)/2
TFSUB=DD+(DS-HF*DD)*ONF
M=CF*CFSUB+CA*CASUB+NF*TR*TFSUB
CFSUB=CFSUB/(M*CF)
CASUB=CASUB/(M*CF)
TFSUB=TFSUB/(M*CF)
GGSUB=(CF*A+(CF-CA/2)*B+CA*C)/M
QQSUB=(TR*(DD*HF+DS)+(CF-CA/2)*E)/M
QPSUB=TR*(NF-1)*DD/M
C---INCLUDE EXTERNAL FACTORS
EMSQ=DOT(P,5,5)
M=M*256*PI**4*CF/EMSQ
ELSEIF (METYPE.EQ.1) THEN
EMSQ=DOT(P,5,5)
A=2*(LEIA(P,P(1,6),1,2,3,4)+LEIA(P,P(1,6),2,1,3,4)
$ +LEIA(P,P(1,6),1,2,4,3)+LEIA(P,P(1,6),2,1,4,3))+EMSQ/2*(
$ ERTA(P,1,2,3,4)+ERTA(P,2,1,3,4)+ERTA(P,1,2,4,3)+ERTA(P,2,1,4,3))
B=2*(LEIB(P,P(1,6),1,2,3,4)+LEIB(P,P(1,6),2,1,3,4)
$ +LEIB(P,P(1,6),1,2,4,3)+LEIB(P,P(1,6),2,1,4,3))+EMSQ/2*(
$ ERTB(P,1,2,3,4)+ERTB(P,2,1,3,4)+ERTB(P,1,2,4,3)+ERTB(P,2,1,4,3))
C=2*(LEIC(P,P(1,6),1,2,3,4)+LEIC(P,P(1,6),2,1,3,4)
$ +LEIC(P,P(1,6),1,2,4,3)+LEIC(P,P(1,6),2,1,4,3))+EMSQ/2*(
$ ERTC(P,1,2,3,4)+ERTC(P,2,1,3,4)+ERTC(P,1,2,4,3)+ERTC(P,2,1,4,3))
DD=2*(LEID(P,P(1,6),1,2,3,4)+LEID(P,P(1,6),2,1,4,3)
$ +LEID(P,P(1,6),3,4,1,2)+LEID(P,P(1,6),4,3,2,1))+EMSQ/2*(
$ ERTD(P,1,2,3,4)+ERTD(P,2,1,4,3)+ERTD(P,3,4,1,2)+ERTD(P,4,3,2,1))
DS=2*(LEID(P,P(1,6),2,1,3,4)+LEID(P,P(1,6),1,2,4,3)
$ +LEID(P,P(1,6),3,4,2,1)+LEID(P,P(1,6),4,3,1,2))+EMSQ/2*(
$ ERTD(P,2,1,3,4)+ERTD(P,1,2,4,3)+ERTD(P,3,4,2,1)+ERTD(P,4,3,1,2))
E=2*(LEIE(P,P(1,6),1,2,3,4)+LEIE(P,P(1,6),2,1,4,3)
$ +LEIE(P,P(1,6),3,4,1,2)+LEIE(P,P(1,6),4,3,2,1)
$ +LEIE(P,P(1,6),2,1,3,4)+LEIE(P,P(1,6),1,2,4,3)
$ +LEIE(P,P(1,6),3,4,2,1)+LEIE(P,P(1,6),4,3,1,2))+EMSQ/2*(
$ ERTE(P,1,2,3,4)+ERTE(P,2,1,4,3)+ERTE(P,3,4,1,2)+ERTE(P,4,3,2,1)+
$ ERTE(P,2,1,3,4)+ERTE(P,1,2,4,3)+ERTE(P,3,4,2,1)+ERTE(P,4,3,1,2))
A=HF*A
B=HF*B
C=HF*C
DD=HF*DD
DS=HF*HF*DS
E=HF*HF*E
CFSUB=A+B+E
CASUB=C-(B+E)/2
TFSUB=DD+(DS-HF*DD)*ONF
M=CF*CFSUB+CA*CASUB+NF*TR*TFSUB
CFSUB=CFSUB/(M*CF)
CASUB=CASUB/(M*CF)
TFSUB=TFSUB/(M*CF)
GGSUB=(CF*A+(CF-CA/2)*B+CA*C)/M
QQSUB=(TR*(DD*HF+DS)+(CF-CA/2)*E)/M
QPSUB=TR*(NF-1)*DD/M
C---INCLUDE EXTERNAL FACTORS
M=M*256*PI**4*CF/EMSQ
M=M*FPAL2*CA*CQ*4/EMSQ
ELSEIF (METYPE.EQ.2) THEN
CALL CONVERT(P)
CALL SETUP
IPS=1
CALL SFMEE(4,0,M)
IPS=2
CALL SFMEE(4,0,T)
M=M+T
ELSE
STOP 'UNKNOWN MATRIX-ELEMENT TYPE IN MATFOR!'
ENDIF
END
C-----------------------------------------------------------------------
SUBROUTINE VIRTWO(P,V)
IMPLICIT NONE
C---CALCULATE THE TWO-PARTON MATRIX-ELEMENT AT NEXT-TO-LEADING ORDER
DOUBLE PRECISION P(4,7),V,M,SUB
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
C---CALCULATE THE LOWEST-ORDER MATRIX-ELEMENT
CALL MATTWO(P,M)
IF (METYPE.EQ.0.OR.METYPE.EQ.1) THEN
C---VIRTUAL CROSS-SECTION, WITH THE POLES REMOVED AND THE LIMIT TAKEN
V=M*CF*(PISQ-8)
ELSEIF (METYPE.EQ.2) THEN
CALL CONVERT(P)
CALL SETUP
CALL SFMEE(2,1,V)
ELSE
STOP 'UNKNOWN MATRIX-ELEMENT TYPE IN VIRTWO!'
ENDIF
C---THE SUBTRACTION
SUB=CF*(10-PISQ)
C---THE TOTAL
V=V + M*SUB
END
C-----------------------------------------------------------------------
SUBROUTINE VIRTHR(P,V)
IMPLICIT NONE
C---CALCULATE THE THREE-PARTON MATRIX-ELEMENT AT NEXT-TO-LEADING ORDER
DOUBLE PRECISION P(4,7),V,DOT,EMSQ,Y12,Y13,Y23,L12,L13,L23,
$ M,ERTV,LEIV,CFTOT,CATOT,TFTOT,TOT
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
DOUBLE PRECISION CFSUB,CASUB,TFSUB,GGSUB,QQSUB,QPSUB
COMMON /SUBCOM/ CFSUB,CASUB,TFSUB,GGSUB,QQSUB,QPSUB
EMSQ=DOT(P,5,5)
Y12=2*DOT(P,1,2)/EMSQ
Y13=2*DOT(P,1,3)/EMSQ
Y23=2*DOT(P,2,3)/EMSQ
L12=LOG(Y12)
L13=LOG(Y13)
L23=LOG(Y23)
C---CALCULATE THE LOWEST-ORDER MATRIX-ELEMENT
CALL MATTHR(P,M)
IF (METYPE.EQ.0) THEN
C---THE FIRST ERT EXPRESSION, WITH THE POLES REMOVED AND THE LIMIT TAKEN
CFTOT=M*(HF*PISQ*2 - 8 - L12**2)
CATOT=M*(HF*PISQ + HF*(L12**2-L13**2-L23**2))
TFTOT=0
C---THE FINITE TERMS NOT PROPORTIONAL TO TREE-LEVEL RESULT
TOT=ERTV(P)
CFTOT=CFTOT+CF*CFSUB*TOT
CATOT=CATOT+CF*CASUB*TOT
TFTOT=TFTOT+CF*TFSUB*TOT
ELSEIF (METYPE.EQ.1) THEN
C---THE FIRST ERT EXPRESSION, WITH THE POLES REMOVED AND THE LIMIT TAKEN
CFTOT=M*(HF*PISQ*2 - 8 - L12**2)
CATOT=M*(HF*PISQ + HF*(L12**2-L13**2-L23**2))
TFTOT=0
C---THE FINITE TERMS NOT PROPORTIONAL TO TREE-LEVEL RESULT
TOT=(FPAL2*CA*CQ*4/EMSQ)*(2*LEIV(P,P(1,6)))
CFTOT=CFTOT+CF*CFSUB*TOT
CATOT=CATOT+CF*CASUB*TOT
TFTOT=TFTOT+CF*TFSUB*TOT
TOT=(FPAL2*CA*CQ*4/EMSQ)*(EMSQ/2*ERTV(P))
CFTOT=CFTOT+CF*CFSUB*TOT
CATOT=CATOT+CF*CASUB*TOT
TFTOT=TFTOT+CF*TFSUB*TOT
ELSEIF (METYPE.EQ.2) THEN
CALL CONVERT(P)
CALL SETUP
CALL SFMEE(3,1,V)
CFTOT=V/CF
CATOT=0
TFTOT=0
ELSE
STOP 'UNKNOWN MATRIX-ELEMENT TYPE IN VIRTHR!'
ENDIF
C---THE SUBTRACTION
CFTOT=CFTOT+M*(-HF*PISQ*2 + 10 + L12**2 - 3D0/2*(2*L12))
CATOT=CATOT+M*(-HF*PISQ + 50D0/9 - HF*(L12**2-L13**2-L23**2)
$ - HF*(11D0/6)*(L13+L23) - 3D0/2*(HF*(L13+L23-2*L12)))
TFTOT=TFTOT+M*( - 16D0/9 - HF*(-2D0/3)*(L13+L23))
C---THE TOTAL
V=CF*CFTOT+CA*CATOT+TR*NF*TFTOT
CFSUB=CFTOT/(CF*V)
CASUB=CATOT/(CF*V)
TFSUB=TFTOT/(CF*V)
GGSUB=CF*(CF*CFSUB+CA*CASUB)
QQSUB=CF*TR*TFSUB
QPSUB=CF*TR*(NF-1)*TFSUB
END
C-----------------------------------------------------------------------
DOUBLE PRECISION FUNCTION ERTV(P)
IMPLICIT NONE
C---RETURN THE ERT F FUNCTION FOR VIRTUAL TERMS THAT ARE NOT
C TRIVIALLY PROPORTIONAL TO TREE-LEVEL
DOUBLE PRECISION P(4,7),DOT,R,X,Y,DILOG,EMSQ,
$ Y12,Y13,Y23,L12,L13,L23
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
DOUBLE PRECISION CFSUB,CASUB,TFSUB,GGSUB,QQSUB,QPSUB
COMMON /SUBCOM/ CFSUB,CASUB,TFSUB,GGSUB,QQSUB,QPSUB
R(X,Y)=LOG(X)*LOG(Y)-LOG(X)*LOG(1-X)-LOG(Y)*LOG(1-Y)+PISQ/6
$ -DILOG(X)-DILOG(Y)
EMSQ=DOT(P,5,5)
Y12=2*DOT(P,1,2)/EMSQ
Y13=2*DOT(P,1,3)/EMSQ
Y23=2*DOT(P,2,3)/EMSQ
L12=LOG(Y12)
L13=LOG(Y13)
L23=LOG(Y23)
CFSUB=Y12/(Y12+Y13)+Y12/(Y12+Y23)+(Y12+Y23)/Y13+(Y12+Y13)/Y23
$ +L13*(4*Y12**2+2*Y12*Y13+4*Y12*Y23+Y13*Y23)/(Y12+Y23)**2
$ +L23*(4*Y12**2+2*Y12*Y23+4*Y12*Y13+Y13*Y23)/(Y12+Y13)**2
$ -2*((Y12**2+(Y12+Y13)**2)/(Y13*Y23)*R(Y12,Y23)
$ +(Y12**2+(Y12+Y23)**2)/(Y13*Y23)*R(Y12,Y13)
$ +(Y13**2+Y23**2)/(Y13*Y23*(Y13+Y23))
$ -2*L12*(Y12**2/(Y13+Y23)**2+2*Y12/(Y13+Y23)))
CASUB=L13*Y13/(Y12+Y23)+L23*Y23/(Y12+Y13)
$ +((Y12**2+(Y12+Y13)**2)/(Y13*Y23)*R(Y12,Y23)
$ +(Y12**2+(Y12+Y23)**2)/(Y13*Y23)*R(Y12,Y13)
$ +(Y13**2+Y23**2)/(Y13*Y23*(Y13+Y23))
$ -2*L12*(Y12**2/(Y13+Y23)**2+2*Y12/(Y13+Y23)))
$ -R(Y13,Y23)*(Y13/Y23+Y23/Y13+2*Y12/(Y13*Y23))
TFSUB=0
ERTV=CF*(CF*CFSUB+CA*CASUB)
CFSUB=CFSUB/ERTV
CASUB=CASUB/ERTV
ERTV=16*PISQ/EMSQ*ERTV
END
C-----------------------------------------------------------------------
DOUBLE PRECISION FUNCTION LEIV(P,K)
IMPLICIT NONE
C---RETURN THE PART OF THE ONE-LOOP HADRONIC TENSOR NOT TRIVIALLY
C PROPORTIONAL TO TREE-LEVEL ONE CONTRACTED WITH A TENSOR -K(MU)K(NU)
DOUBLE PRECISION P(4,7),K(4),DOT,R,X,Y,Z,DILOG,EMSQ,Y12,Y13,Y23,
$ L12,L13,L23,A,B,C,D,P1K,P2K,P3K,KK,
$ CF1,CF2,CF3,CF4,CA1,CA2,CA3,CA4
PARAMETER (Z=0)
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
DOUBLE PRECISION CFSUB,CASUB,TFSUB,GGSUB,QQSUB,QPSUB
COMMON /SUBCOM/ CFSUB,CASUB,TFSUB,GGSUB,QQSUB,QPSUB
R(X,Y)=LOG(X)*LOG(Y)-LOG(X)*LOG(1-X)-LOG(Y)*LOG(1-Y)+PISQ/6
$ -DILOG(X)-DILOG(Y)
EMSQ=DOT(P,5,5)
Y12=2*DOT(P,1,2)/EMSQ
Y13=2*DOT(P,1,3)/EMSQ
Y23=2*DOT(P,2,3)/EMSQ
L12=LOG(Y12)
L13=LOG(Y13)
L23=LOG(Y23)
C---FIRST DECOMPOSE K AS A*P1+B*P2+C*P3+D*E_(MU,P1,P2,P3)/Q^2
P1K=P(4,1)*K(4)-P(3,1)*K(3)-P(2,1)*K(2)-P(1,1)*K(1)
P2K=P(4,2)*K(4)-P(3,2)*K(3)-P(2,2)*K(2)-P(1,2)*K(1)
P3K=P(4,3)*K(4)-P(3,3)*K(3)-P(2,3)*K(2)-P(1,3)*K(1)
KK=K(4)*K(4)-K(3)*K(3)-K(2)*K(2)-K(1)*K(1)
A=(P3K*Y12+P2K*Y13-P1K*Y23)/(Y12*Y13*EMSQ)
B=(P1K*Y23+P3K*Y12-P2K*Y13)/(Y12*Y23*EMSQ)
C=(P2K*Y13+P1K*Y23-P3K*Y12)/(Y23*Y13*EMSQ)
D=SQRT(MAX(Z,4*(KK/EMSQ-A*B*Y12-A*C*Y13-B*C*Y23)/(-Y12*Y13*Y23)))
C---THEN CALCULATE THE CONTRACTIONS WITH -P1(MU)P1(NU) ETC
CF1=R(Y13,Y12)*Y12-R(Y23,Y12)*Y12**2/Y13
$ -L12*Y12*Y13/(Y13+Y23)**2-L23*Y12+Y12/2*(Y23-Y13)/(Y23+Y13)
CA1=-R(Y13,Y12)*Y12/2+R(Y23,Y12)*Y12**2/Y13/2+R(Y23,Y13)*Y12/2
$ +L12*Y12*Y13/(Y13+Y23)**2/2-Y12*Y23/(Y23+Y13)/2
CF2=R(Y23,Y12)*Y12-R(Y13,Y12)*Y12**2/Y23
$ -L12*Y12*Y23/(Y13+Y23)**2-L13*Y12+Y12/2*(Y13-Y23)/(Y13+Y23)
CA2=-R(Y23,Y12)*Y12/2+R(Y13,Y12)*Y12**2/Y23/2+R(Y23,Y13)*Y12/2
$ +L12*Y12*Y23/(Y13+Y23)**2/2-Y12*Y13/(Y13+Y23)/2
CF3=R(Y13,Y12)*Y12+R(Y23,Y12)*Y12-2*L12*Y12
$ -L13*Y12*Y23/2/(Y12+Y23)**2*(1+Y12+Y23)
$ -L23*Y12*Y13/2/(Y12+Y13)**2*(1+Y12+Y13)
$ -Y12/2*(Y13/(Y12+Y13)+Y23/(Y12+Y23))
CA3=-R(Y13,Y12)*Y12/2-R(Y23,Y12)*Y12/2+R(Y23,Y13)*Y12
$ +L12*Y12+L13*Y12*Y13/(Y12+Y23)/2+L23*Y12*Y23/(Y12+Y13)/2
CF4=R(Y13,Y12)*Y12/4/Y23*(Y12-Y12**2-Y12*Y23+2*Y12**2*Y23
$ +2*Y12*Y23**2+Y23**3)
$ +R(Y23,Y12)*Y12/4/Y13*(Y12-Y12**2-Y12*Y13+2*Y12**2*Y13
$ +2*Y12*Y13**2+Y13**3)
$ +L12*Y12**2/4/(Y13+Y23)*(Y13+Y23-2*Y13*Y23)
$ -L13*Y12/8/(Y12+Y23)*Y13*(Y12+Y13)*(Y23-2*Y12)
$ -L23*Y12/8/(Y12+Y13)*Y23*(Y12+Y23)*(Y13-2*Y12)
$ +Y12/8*(Y13+Y23-2*Y13*Y23)
CA4=-R(Y13,Y12)*Y12/8/Y23*(Y12-Y12**2-Y12*Y23+2*Y12**2*Y23
$ +2*Y12*Y23**2+Y23**3)
$ -R(Y23,Y12)*Y12/8/Y13*(Y12-Y12**2-Y12*Y13+2*Y12**2*Y13
$ +2*Y12*Y13**2+Y13**3)
$ +R(Y13,Y23)*Y12/8*((1-Y13)**2+(1-Y23)**2)
$ -L12*Y12**2/8/(Y13+Y23)*(Y13+Y23-2*Y13*Y23)
$ -L13*Y12/8*Y13*(Y12+Y13)-L23*Y12/8*Y23*(Y12+Y23)
$ -Y12/8*(Y13+Y23-2*Y13*Y23)
C---AND COMBINE THEM WITH THE APPROPRIATE WEIGHTS
CFSUB=(A-B)*(A-C)*CF1+(B-C)*(B-A)*CF2+(C-A)*(C-B)*CF3+D*D*CF4
CASUB=(A-B)*(A-C)*CA1+(B-C)*(B-A)*CA2+(C-A)*(C-B)*CA3+D*D*CA4
TFSUB=0
LEIV=CF*(CF*CFSUB+CA*CASUB)
CFSUB=CFSUB/LEIV
CASUB=CASUB/LEIV
LEIV=16*PISQ*LEIV
END
C-----------------------------------------------------------------------
SUBROUTINE SUBTHR(PERM,P,Q,S,JAC,*)
IMPLICIT NONE
C---GENERATE A TWO-PARTON STATE FROM A THREE-PARTON STATE,
C CALCULATE THE JACOBIAN FACTOR FOR THE CORRESPONDING CHANNEL,
C AND (IF PERM.GT.0) THE APPROXIMATE MATRIX-ELEMENT.
INTEGER NPERM,PERM,IPERM,IJF,KF,I,J,K,M
DOUBLE PRECISION P(4,7),Q(4,7),S,JAC,DOT,EMSQ,DEN,Y,ZI,ZJ,OY,ZTI
PARAMETER (NPERM=2)
DIMENSION IPERM(3,NPERM),IJF(NPERM),KF(NPERM)
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
INTEGER NPOW1,NPOW2
DOUBLE PRECISION XPOW1,XPOW2,COSP,COSM,COSZ
COMMON /SAMCOM/ XPOW1,XPOW2,COSP,COSM,COSZ,NPOW1,NPOW2
DATA IPERM/1,3,2, 2,3,1/
DATA IJF/1,2/
DATA KF/2,1/
IF (ABS(PERM).GT.NPERM.OR.PERM.EQ.0)
$ STOP 'PERM TOO BIG IN SUBTHR!'
C---FIND WHICH PARTONS TO TREAT
I=IPERM(1,ABS(PERM))
J=IPERM(2,ABS(PERM))
K=IPERM(3,ABS(PERM))
C---FIND THE KINEMATIC VARIABLES
EMSQ=2*(DOT(P,I,J)+DOT(P,J,K)+DOT(P,K,I))
IF (EMSQ.LE.0) CALL WARNER('SUBTHR',1,*999)
DEN=2/EMSQ
Y=DOT(P,I,J)*DEN
IF (Y.LE.0.OR.Y.GE.1) CALL WARNER('SUBTHR',2,*999)
ZI=DOT(P,I,K)*DEN
IF (ZI.LE.0.OR.ZI.GE.1) CALL WARNER('SUBTHR',3,*999)
ZJ=DOT(P,J,K)*DEN
IF (ZJ.LE.0.OR.ZJ.GE.1) CALL WARNER('SUBTHR',4,*999)
OY=1/(1-Y)
ZTI=ZI*OY
C---COPY INTO Q, REPLACING K BY KTILDE AND I BY IJTILDE
DO M=1,4
Q(M,IJF(ABS(PERM)))=P(M,I)+P(M,J)-Y*OY*P(M,K)
Q(M,KF(ABS(PERM)))=OY*P(M,K)
Q(M,5)=P(M,5)
Q(M,6)=P(M,6)
Q(M,7)=P(M,7)
ENDDO
C---CALCULATE THE CORRESPONDING JACOBIAN FACTOR
CALL JACTWO(Q,JAC)
JAC=JAC/(4*NPOW1**2*(1-ZI)*(1-ZJ)*Y**XPOW1)*(2-ZI-ZJ)
C---INCLUDE A PRIORI CHANNEL WEIGHTS
JAC=JAC/2
IF (PERM.LT.0) RETURN
C---CALCULATE WEIGHT FOR QUARK-GLUON SPLITTING FUNCTION
CALL MATTWO(Q,S)
S=CF*S*(2/(1-ZTI*(1-Y))-(1+ZTI))
C---INCLUDE OVERALL FACTOR
DEN=1/(Y*EMSQ)
S=S*16*PISQ*DEN
RETURN
999 RETURN 1
END
C-----------------------------------------------------------------------
SUBROUTINE SUBFOR(PERM,P,Q,S,JAC,KEEP,*)
IMPLICIT NONE
C---GENERATE A THREE-PARTON STATE FROM A FOUR-PARTON STATE,
C CALCULATE THE JACOBIAN FACTOR FOR THE CORRESPONDING CHANNEL,
C AND (IF PERM.GT.0) THE APPROXIMATE MATRIX-ELEMENT.
C IF ANY DOT PRODUCTS ARE BELOW CUTOFF, EVENT IS REJECTED,
C BY JUMPING TO THE SPECIFIED LABEL
C IF ANY DOT PRODUCTS ARE BELOW CUTUP, EVENT IS MARKED BY KEEP=.TRUE.
INTEGER NPERM,PERM,IPERM,IJF,KF,LF,NPERM3,I,J,K,L,M,N
LOGICAL KEEP
DOUBLE PRECISION P(4,7),Q(4,7),S,S1,S2,S3,JAC,DOT,EMSQ,QUSQ,T,
$ DEN,Y,ZI,ZJ,OY,ZTI,ZTJ,OX1,OX2,JTMP,STMP,QTMP(4,7),V(4),VV
PARAMETER (NPERM=10,NPERM3=2)
DIMENSION IPERM(4,NPERM),IJF(NPERM),KF(NPERM),LF(NPERM)
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
INTEGER NPOW1,NPOW2
DOUBLE PRECISION XPOW1,XPOW2,COSP,COSM,COSZ
COMMON /SAMCOM/ XPOW1,XPOW2,COSP,COSM,COSZ,NPOW1,NPOW2
DOUBLE PRECISION CFSUB,CASUB,TFSUB,GGSUB,QQSUB,QPSUB
COMMON /SUBCOM/ CFSUB,CASUB,TFSUB,GGSUB,QQSUB,QPSUB
DATA IPERM/1,3,2,4, 1,3,4,2, 1,4,2,3, 1,4,3,2,
$ 2,4,1,3, 2,4,3,1, 2,3,1,4, 2,3,4,1,
$ 3,4,1,2, 3,4,2,1/
DATA IJF/1,1,1,1,2,2,2,2,3,3/
DATA KF/2,3,2,3,1,3,1,3,1,2/
DATA LF/3,2,3,2,3,1,3,1,2,1/
IF (ABS(PERM).GT.NPERM.OR.PERM.EQ.0)
$ STOP 'PERM TOO BIG IN SUBFOR!'
C---FIND WHICH PARTONS TO TREAT
I=IPERM(1,ABS(PERM))
J=IPERM(2,ABS(PERM))
K=IPERM(3,ABS(PERM))
L=IPERM(4,ABS(PERM))
C---FIND THE KINEMATIC VARIABLES
EMSQ=2*(DOT(P,I,J)+DOT(P,J,K)+DOT(P,K,I))
IF (EMSQ.LE.0) CALL WARNER('SUBFOR',1,*999)
DEN=2/EMSQ
Y=DOT(P,I,J)*DEN
IF (Y.LE.0.OR.Y.GE.1) CALL WARNER('SUBFOR',2,*999)
ZI=DOT(P,I,K)*DEN
IF (ZI.LE.0.OR.ZI.GE.1) CALL WARNER('SUBFOR',3,*999)
ZJ=DOT(P,J,K)*DEN
IF (ZJ.LE.0.OR.ZJ.GE.1) CALL WARNER('SUBFOR',4,*999)
OY=1/(1-Y)
ZTI=ZI*OY
ZTJ=ZJ*OY
C---COPY INTO Q, REPLACING K BY KTILDE AND I BY IJTILDE
DO M=1,4
Q(M,IJF(ABS(PERM)))=P(M,I)+P(M,J)-Y*OY*P(M,K)
Q(M,KF(ABS(PERM)))=OY*P(M,K)
Q(M,LF(ABS(PERM)))=P(M,L)
Q(M,5)=P(M,5)
Q(M,6)=P(M,6)
Q(M,7)=P(M,7)
ENDDO
C---REENFORCE THE MINIMUM CUTOFF ON ALL PAIR MASSES
QUSQ=DOT(Q,5,5)
OX1=2*DOT(Q,2,3)/QUSQ
OX2=2*DOT(Q,1,3)/QUSQ
IF (OX1.LT.CUTOFF.OR.OX2.LT.CUTOFF.OR.1-OX1-OX2.LT.CUTOFF)
$ RETURN 1
IF (OX1.LT.CUTUP.OR.OX2.LT.CUTUP.OR.1-OX1-OX2.LT.CUTUP)
$ KEEP=.TRUE.
C---CALCULATE THE CORRESPONDING JACOBIAN FACTOR
JAC=0
DO M=1,NPERM3
CALL SUBTHR(-M,Q,QTMP,STMP,JTMP,*999)
JAC=JAC+JTMP
ENDDO
IF (ABS(PERM).LE.8) THEN
JAC=JAC/(2*NPOW2**2*(1-ZI)*Y**XPOW2)
ELSE
JAC=JAC/(4*NPOW2**2*(1-ZI)*(1-ZJ)*Y**XPOW2)*(2-ZI-ZJ)
ENDIF
JAC=JAC*QUSQ/EMSQ
C---INCLUDE A PRIORI CHANNEL WEIGHTS
JAC=JAC/12
IF (ABS(PERM).GT.8) JAC=JAC*2
IF (PERM.LT.0) RETURN
C---CALCULATE WEIGHT FOR QUARK-GLUON SPLITTING FUNCTION
IF (PERM.LE.8) THEN
CALL MATTHR(Q,S1)
S1=S1*(2/(1-ZTI*(1-Y))-(1+ZTI))
IF (KF(PERM).EQ.3) THEN
S1=S1*HF*CA
ELSE
S1=S1*(CF-HF*CA)
ENDIF
C---THEN PERMUTE Q
IF (PERM.LE.4) THEN
DO M=1,4
T=Q(M,1)
Q(M,1)=Q(M,2)
Q(M,2)=Q(M,3)
Q(M,3)=T
ENDDO
ELSE
DO M=1,4
T=Q(M,3)
Q(M,3)=Q(M,2)
Q(M,2)=T
ENDDO
ENDIF
ELSE
S1=0
ENDIF
C---CALCULATE WEIGHT FOR GLUON DECAY
DEN=1/(Y*EMSQ)
CALL MATTHR(Q,S2)
DO M=1,4
V(M)=ZTI*P(M,I)-ZTJ*P(M,J)
ENDDO
VV=-ZTI*ZTJ*Y*EMSQ
CALL CONTHR(Q,V,VV,S3)
S3=4*ZTI*ZTJ*S3
IF (PERM.LE.8) THEN
S2=S2-S3
IF (MOD(PERM-1,4).LE.1) THEN
S2=S2*HF*TR*(NF-HF)*2
ELSE
S2=S2*HF*TR
ENDIF
ELSE
S2=S2*(2/(1-ZTI*(1-Y))+2/(1-ZTJ*(1-Y))-4)+S3
S2=S2*HF*CA
ENDIF
C---INCLUDE SYMMETRY FACTORS
S1=S1/2
IF (PERM.LE.8) THEN
S2=S2/4
ELSE
S2=S2/2
ENDIF
C---INCLUDE OVERALL FACTOR
S=(S1+S2)*16*PISQ*DEN
IF (PERM.LE.8) THEN
CASUB=S1/(S1+S2)
TFSUB=(1-CASUB)/(TR*CF)*ONF
IF (KF(PERM).EQ.3) THEN
CFSUB=0
CASUB=CASUB/(CA*CF)
ELSE
CFSUB=CASUB/((CF-CA/2)*CF)
CASUB=CASUB/((CA-2*CF)*CF)
ENDIF
ELSE
CASUB=1/(CA*CF)
CFSUB=0
TFSUB=0
ENDIF
RETURN
999 RETURN 1
END
C-----------------------------------------------------------------------
FUNCTION ERTA(P,I,J,K,L)
IMPLICIT NONE
C---EVALUATE THE ERT A FUNCTION WITH P(*,I)=P1, P(*,J)=P2, ETC
INTEGER I,J,K,L
DOUBLE PRECISION ERTA,P(4,7),DOT,
$ S12,S13,S14,S23,S24,S34,S134,S234,S
S12=2*DOT(P,I,J)
S13=2*DOT(P,I,K)
S14=2*DOT(P,I,L)
S23=2*DOT(P,J,K)
S24=2*DOT(P,J,L)
S34=2*DOT(P,K,L)
S134=S13+S14+S34
S234=S23+S24+S34
S=S12+S13+S14+S23+S24+S34
ERTA=(S12*S34**2-S13*S24*S34+S14*S23*S34+3*S12*S23*S34+
$ 3*S12*S14*S34+4*S12**2*S34-S13*S23*S24+2*S12*S23*S24-
$ S13*S14*S24-2*S12*S13*S24+2*S12**2*S24+S14*S23**2+
$ 2*S12*S23**2+S14**2*S23+4*S12*S14*S23+4*S12**2*S23+
$ 2*S12*S14**2+2*S12*S13*S14+4*S12**2*S14+2*S12**2*S13+
$ 2*S12**3)/(2*S13*S134*S234*S24)+
$ (S24*S34+S12*S34+S13*S24-S14*S23+S12*S13)/(S13*S134**2)+
$ 2*S23*(S-S13)/(S13*S134*S24)+
$ S34/(2*S13*S24)
END
C-----------------------------------------------------------------------
FUNCTION ERTB(P,I,J,K,L)
IMPLICIT NONE
C---EVALUATE THE ERT B FUNCTION WITH P(*,I)=P1, P(*,J)=P2, ETC
INTEGER I,J,K,L
DOUBLE PRECISION ERTB,P(4,7),DOT,
$ S12,S13,S14,S23,S24,S34,S123,S124,S134,S234,S
S12=2*DOT(P,I,J)
S13=2*DOT(P,I,K)
S14=2*DOT(P,I,L)
S23=2*DOT(P,J,K)
S24=2*DOT(P,J,L)
S34=2*DOT(P,K,L)
S123=S12+S13+S23
S124=S12+S14+S24
S134=S13+S14+S34
S234=S23+S24+S34
S=S12+S13+S14+S23+S24+S34
ERTB=(S12*S24*S34+S12*S14*S34-S13*S24**2+S13*S14*S24+
$ 2*S12*S14*S24)/(S13*S134*S23*S14)+
$ S12*(S+S34)*S124/(S134*S234*S14*S24)-
$ (2*S13*S24+S14**2+S13*S23+2*S12*S13)/(S13*S134*S14)+
$ S12*S123*S124/(2*S13*S14*S23*S24)
END
C-----------------------------------------------------------------------
FUNCTION ERTC(P,I,J,K,L)
IMPLICIT NONE
C---EVALUATE THE ERT C FUNCTION WITH P(*,I)=P1, P(*,J)=P2, ETC
INTEGER I,J,K,L
DOUBLE PRECISION ERTC,P(4,7),DOT,
$ S12,S13,S14,S23,S24,S34,S134,S234
S12=2*DOT(P,I,J)
S13=2*DOT(P,I,K)
S14=2*DOT(P,I,L)
S23=2*DOT(P,J,K)
S24=2*DOT(P,J,L)
S34=2*DOT(P,K,L)
S134=S13+S14+S34
S234=S23+S24+S34
ERTC=-(5*S12*S34**2+2*S12*S24*S34+2*S12*S23*S34+2*S12*S14*S34+
$ 2*S12*S13*S34+4*S12**2*S34-S13*S24**2+S14*S23*S24+
$ S13*S23*S24+S13*S14*S24-S12*S14*S24-S13**2*S24-
$ 3*S12*S13*S24-S14*S23**2-S14**2*S23+S13*S14*S23-
$ 3*S12*S14*S23-S12*S13*S23)/(4*S134*S234*S34**2)+
$ (3*S12*S34**2-3*S13*S24*S34+3*S12*S24*S34+3*S14*S23*S34-
$ S13*S24**2-S12*S23*S34+6*S12*S14*S34+2*S12*S13*S34-
$ 2*S12**2*S34+S14*S23*S24-3*S13*S23*S24-2*S13*S14*S24+
$ 4*S12*S14*S24+2*S12*S13*S24+3*S14*S23**2+2*S14**2*S23+
$ 2*S14**2*S12+2*S12**2*S14+6*S12*S14*S23-2*S12*S13**2-
$ 2*S12**2*S13)/(4*S13*S134*S234*S34)+
$ (2*S12*S34**2-2*S13*S24*S34+S12*S24*S34+4*S13*S23*S34+
$ 4*S12*S14*S34+2*S12*S13*S34+2*S12**2*S34-S13*S24**2+
$ 3*S14*S23*S24+4*S13*S23*S24-2*S13*S14*S24+4*S12*S14*S24+
$ 2*S12*S13*S24+2*S14*S23**2+4*S13*S23**2+2*S13*S14*S23+
$ 2*S12*S14*S23+4*S12*S13*S23+2*S12*S14**2+4*S12**2*S13+
$ 4*S12*S13*S14+2*S12**2*S14)/(4*S13*S134*S24*S34)
ERTC=ERTC-
$ (S12*S34**2-2*S14*S24*S34-2*S13*S24*S34-S14*S23*S34+
$ S13*S23*S34+S12*S14*S34+2*S12*S13*S34-2*S14**2*S24-
$ 4*S13*S14*S24-4*S13**2*S24-S14**2*S23-S13**2*S23+
$ S12*S13*S14-S12*S13**2)/(2*S13*S34*S134**2)+
$ (S12*S34**2-4*S14*S24*S34-2*S13*S24*S34-2*S14*S23*S34-
$ 4*S13*S23*S34-4*S12*S14*S34-4*S12*S13*S34-2*S13*S14*S24+
$ 2*S13**2*S24+2*S14**2*S23-2*S13*S14*S23-S12*S14**2-
$ 6*S12*S13*S14-S12*S13**2)/(4*S34**2*S134**2)
END
C-----------------------------------------------------------------------
FUNCTION ERTD(P,I,J,K,L)
IMPLICIT NONE
C---EVALUATE THE ERT D FUNCTION WITH P(*,I)=P1, P(*,J)=P2, ETC
INTEGER I,J,K,L
DOUBLE PRECISION ERTD,P(4,7),DOT,
$ S12,S13,S14,S23,S24,S34,S123,S134
S12=2*DOT(P,I,J)
S13=2*DOT(P,I,K)
S14=2*DOT(P,I,L)
S23=2*DOT(P,J,K)
S24=2*DOT(P,J,L)
S34=2*DOT(P,K,L)
S123=S12+S13+S23
S134=S13+S14+S34
ERTD=(S13*S23*S34+S12*S23*S34-S12**2*S34+S13*S23*S24+
$ 2*S12*S23*S24-S14*S23**2+S12*S13*S24+S12*S14*S23+
$ S12*S13*S14)/(S13**2*S123**2)-
$ (S12*S34**2-S13*S24*S34+S12*S24*S34-S14*S23*S34-
$ S12*S23*S34-S13*S24**2+S14*S23*S24-S13*S23*S24-
$ S13**2*S24+S14*S23**2)/(S13**2*S123*S134)
END
C-----------------------------------------------------------------------
FUNCTION ERTE(P,I,J,K,L)
IMPLICIT NONE
C---EVALUATE THE ERT E FUNCTION WITH P(*,I)=P1, P(*,J)=P2, ETC
INTEGER I,J,K,L
DOUBLE PRECISION ERTE,P(4,7),DOT,
$ S12,S13,S14,S23,S24,S34,S123,S124,S134,S234
S12=2*DOT(P,I,J)
S13=2*DOT(P,I,K)
S14=2*DOT(P,I,L)
S23=2*DOT(P,J,K)
S24=2*DOT(P,J,L)
S34=2*DOT(P,K,L)
S123=S12+S13+S23
S124=S12+S14+S24
S134=S13+S14+S34
S234=S23+S24+S34
ERTE=(S12*S23*S34-S12*S24*S34+S12*S14*S34+S12*S13*S34+S13*S24**2-
$ S14*S23*S24+S13*S23*S24+S13*S14*S24+S13**2*S24-S14*S23**2-
$ S14**2*S23-S13*S14*S23)/(S13*S23*S123*S134)-
$ S12*(S12*S34-S23*S24-S13*S24-S14*S23-
$ S14*S13)/(S13*S23*S123**2)-
$ (S14+S13)*(S24+S23)*S34/(S13*S23*S134*S234)
END
C-----------------------------------------------------------------------
FUNCTION LEIA(P,Q,I,J,K,L)
IMPLICIT NONE
C---EVALUATE THE MATRIX ELEMENT CONTRACTED WITH A TENSOR -Q(MU)Q(NU)
C WITH P(*,I)=P1, P(*,J)=P2, ETC
INTEGER I,J,K,L
DOUBLE PRECISION LEIA,P(4,7),Q(4),DOT,
$ P12,P13,P14,P23,P24,P34,P15,P25,P35,Q2,
$ P1K,P2K,P3K,P4K,KK
P12=2*DOT(P,I,J)
P13=2*DOT(P,I,K)
P14=2*DOT(P,I,L)
P23=2*DOT(P,J,K)
P24=2*DOT(P,J,L)
P34=2*DOT(P,K,L)
P15=P23+P24+P34
P25=P13+P14+P34
P35=P12+P14+P24
Q2=P12+P13+P14+P23+P24+P34
P1K=P(4,I)*Q(4)-P(3,I)*Q(3)-P(2,I)*Q(2)-P(1,I)*Q(1)
P2K=P(4,J)*Q(4)-P(3,J)*Q(3)-P(2,J)*Q(2)-P(1,J)*Q(1)
P3K=P(4,K)*Q(4)-P(3,K)*Q(3)-P(2,K)*Q(2)-P(1,K)*Q(1)
P4K=P(4,L)*Q(4)-P(3,L)*Q(3)-P(2,L)*Q(2)-P(1,L)*Q(1)
KK=Q(4)*Q(4)-Q(3)*Q(3)-Q(2)*Q(2)-Q(1)*Q(1)
LEIA = 0
LEIA = LEIA + P1K*P2K * ( - 2*Q2*P12*P25 - Q2*P14*
+ P25 - Q2*P23*P25 + P12*P13*P25 + P12*P24*P25 + 2*P12*P25*
+ P34 - P13*P23*P25 - 2*P13*P24*P25 - P13*P25*P34 + 2*P14*P15*
+ P24 - 2*P14*P23*P25 - P14*P24*P25 - 2*P15*P23*P25 - 2*P15*P24
+ *P25 - 2*P15*P25*P34 - P24*P25*P34 )
LEIA = LEIA + P1K*P3K * ( - Q2*P12 + Q2*P24 + P12*
+ P13 + P14*P24 + 2*P15*P24 - P24*P34 )*P25
LEIA = LEIA + P1K*P4K * ( - Q2*P12 - Q2*P23 + P12*
+ P13 + P12*P34 - P14*P23 )*P25
LEIA = LEIA + P1K**2 * ( Q2*P23 + Q2*P24 - P13*P23
+ - P13*P24 - P24*P34 )*P25
LEIA = LEIA + P2K*P3K * ( - Q2*P12*P25 - Q2*P14*
+ P25 - 2*P12*P15*P25 + P12*P24*P25 + P12*P25*P34 + 2*P14*P15*
+ P24 - P14*P23*P25 - 4*P15*P23*P25 - 2*P15*P24*P25 - 2*P15*P25
+ *P34 )
LEIA = LEIA + P2K*P4K * ( - Q2*P12*P25 + Q2*P13*
+ P25 + P12*P24*P25 + 2*P13*P15*P25 + P13*P23*P25 - P13*P25*P34
+ + 2*P14*P15*P24 - 2*P15*P23*P25 - 2*P15*P24*P25 )
LEIA = LEIA + P2K**2 * ( Q2*P13 + Q2*P14 + 2*P13*P15
+ - P13*P24 - P13*P34 - P14*P24 + 2*P15*P34 )*P25
LEIA = LEIA + P3K*P4K * ( - 2*P12*P15 + P12*P34 - P13*
+ P24 - P14*P23 - 2*P15*P23 - P15*P25 )*P25
LEIA = LEIA + P3K**2 * ( P14 + 2*P15 )*P24*P25
LEIA = LEIA + P4K**2 * ( P13*P23*P25 )
c$$$ LEIA = LEIA + KK * ( 2*Q2*P12*P14*P25 + 2*Q2*P12*P23
c$$$ + *P25 + 2*Q2*P12**2*P25 - 2*Q2*P14*P15*P24 + 2*Q2*P14*
c$$$ + P23*P25 + P12*P13*P25*P34 + 4*P12*P15*P23*P25 + 2*P12*P15*P25
c$$$ + *P34 + P12*P24*P25*P34 - P13*P14*P23*P25 - 2*P13*P14*P24*P25
c$$$ + - 2*P13*P15*P24*P25 - 2*P13*P23*P24*P25 - P13*P24**2*P25 -
c$$$ + P13**2*P24*P25 + 2*P14*P15*P23*P25 - P14*P23*P24*P25 + 4*P15*
c$$$ + P23*P24*P25 + 4*P15*P23*P25*P34 + 4*P15*P23**2*P25 + 2*P15*
c$$$ + P24*P25*P35 + P15*P25**2*P34 )/4
LEIA = LEIA/(P15*P25**2*P13*P24)
END
C-----------------------------------------------------------------------
FUNCTION LEIB(P,Q,I,J,K,L)
IMPLICIT NONE
C---EVALUATE THE MATRIX ELEMENT CONTRACTED WITH A TENSOR -Q(MU)Q(NU)
C WITH P(*,I)=P1, P(*,J)=P2, ETC
INTEGER I,J,K,L
DOUBLE PRECISION LEIB,P(4,7),Q(4),DOT,
$ P12,P13,P14,P23,P24,P34,P15,P25,P35,P45,Q2,
$ P1K,P2K,P3K,P4K,KK
P12=2*DOT(P,I,J)
P13=2*DOT(P,I,K)
P14=2*DOT(P,I,L)
P23=2*DOT(P,J,K)
P24=2*DOT(P,J,L)
P34=2*DOT(P,K,L)
P15=P23+P24+P34
P25=P13+P14+P34
P35=P12+P14+P24
P45=P12+P13+P23
Q2=P12+P13+P14+P23+P24+P34
P1K=P(4,I)*Q(4)-P(3,I)*Q(3)-P(2,I)*Q(2)-P(1,I)*Q(1)
P2K=P(4,J)*Q(4)-P(3,J)*Q(3)-P(2,J)*Q(2)-P(1,J)*Q(1)
P3K=P(4,K)*Q(4)-P(3,K)*Q(3)-P(2,K)*Q(2)-P(1,K)*Q(1)
P4K=P(4,L)*Q(4)-P(3,L)*Q(3)-P(2,L)*Q(2)-P(1,L)*Q(1)
KK=Q(4)*Q(4)-Q(3)*Q(3)-Q(2)*Q(2)-Q(1)*Q(1)
LEIB = 0
LEIB = LEIB + P1K*P2K * ( - 4*Q2*P14*P24*P45 - 2*P12
+ *P15*P25*P34 - P12*P15*P25*P35 - P12*P15*P25*P45 + 8*P13*P15*
+ P23*P24 + 4*P13*P15*P24*P34 + 4*P13*P15*P24**2 + 4*P14*P15*
+ P23*P24 + 2*P14*P15*P24*P45 + 2*P14*P24*P25*P45 - 4*P15*P23*
+ P24*P25 + 4*P15*P23*P24*P34 )
LEIB = LEIB + P1K*P3K * ( - P12*P14*P15*P25 - 2*P12*
+ P14*P24*P45 + P12*P15*P24*P25 + 4*P12*P15*P24*P34 - P12**2*
+ P15*P25 - 4*P13*P15*P24**2 + 4*P14*P15*P23*P24 )
LEIB = LEIB + P1K*P4K * ( - P12*P13*P15*P25 - 2*P12*
+ P14*P24*P45 + P12*P15*P23*P25 - P12**2*P15*P25 + 4*P13*P15*
+ P23*P24 + 4*P14*P15*P23*P24 )
LEIB = LEIB + P1K**2 * ( 2*Q2*P14*P24*P45 - 2*P12*P14*
+ P24*P45 + P12*P15**2*P25 - 2*P14*P24*P25*P45 - 4*P15*P23*P24*
+ P34 )
LEIB = LEIB + P2K*P3K * ( 4*P12*P13*P15*P24 + P12*P14*
+ P15*P25 - 2*P12*P14*P24*P45 - P12*P15*P24*P25 - P12**2*P15*
+ P25 + 4*P13*P15*P23*P24 + 4*P13*P15*P24**2 )
LEIB = LEIB + P2K*P4K * ( - 4*P12*P13*P15*P24 + P12*
+ P13*P15*P25 - 8*P12*P14*P15*P24 - 2*P12*P14*P24*P45 - P12*P15
+ *P23*P25 - 4*P12*P15*P24*P34 - P12**2*P15*P25 - 4*P13*P14*P15
+ *P24 + 4*P13*P15*P23*P24 + 4*P13*P15*P24**2 - 4*P13**2*P15*
+ P24 )
LEIB = LEIB + P2K**2 * ( 2*Q2*P14*P24*P45 - 2*P12*P14*
+ P24*P45 + P12*P15*P25**2 - 4*P13*P14*P15*P24 - 4*P13*P15*P24*
+ P34 - 4*P13**2*P15*P24 - 2*P14*P15*P24*P45 )
LEIB = LEIB + P3K*P4K * ( - 2*P12*P25 - 4*P14*P24 )
+ *P12*P15
LEIB = LEIB + P3K**2 * ( - 4*P12*P14*P15*P24 )
c$$$ LEIB = LEIB + KK * ( 2*Q2*P12*P14*P24*P45 + Q2*
c$$$ + P12**2*P15*P25 - 2*Q2*P13*P15*P23*P24 - 2*Q2*P14*P15*P23*
c$$$ + P24 + 2*Q2*P15*P23*P24*P25 + P12*P13*P14*P15*P25 - 4*P12*
c$$$ + P13*P15*P23*P24 - 2*P12*P13*P15*P24*P34 + 2*P12*P14*P15*P24*
c$$$ + P34 + 4*P12*P14*P15*P24**2 + P12*P15*P23*P24*P25 - 2*P12*P15*
c$$$ + P23*P24*P34 + 2*P12*P15*P24**2*P34 - 2*P13*P14*P15*P23*P24 +
c$$$ + 2*P13*P14*P15*P24**2 - 2*P13*P15*P23*P24**2 - 2*P13*P15*
c$$$ + P24**3 + 2*P13**2*P15*P24**2 + 2*P14*P15*P23*P24**2 + 2*P14*
c$$$ + P15*P23**2*P24 - 2*P14**2*P15*P23*P24 - 2*P15**2*P23*P24*P25
c$$$ + )/2
LEIB = LEIB/(2*P13*P14*P15*P23*P24*P25)
END
C-----------------------------------------------------------------------
FUNCTION LEIC(P,Q,I,J,K,L)
IMPLICIT NONE
C---EVALUATE THE MATRIX ELEMENT CONTRACTED WITH A TENSOR -Q(MU)Q(NU)
C WITH P(*,I)=P1, P(*,J)=P2, ETC
INTEGER I,J,K,L
DOUBLE PRECISION LEIC,P(4,7),Q(4),DOT,
$ P12,P13,P14,P23,P24,P34,P15,P25,P35,P45,Q2,
$ P1K,P2K,P3K,P4K,KK
P12=2*DOT(P,I,J)
P13=2*DOT(P,I,K)
P14=2*DOT(P,I,L)
P23=2*DOT(P,J,K)
P24=2*DOT(P,J,L)
P34=2*DOT(P,K,L)
P15=P23+P24+P34
P25=P13+P14+P34
P35=P12+P14+P24
P45=P12+P13+P23
Q2=P12+P13+P14+P23+P24+P34
P1K=P(4,I)*Q(4)-P(3,I)*Q(3)-P(2,I)*Q(2)-P(1,I)*Q(1)
P2K=P(4,J)*Q(4)-P(3,J)*Q(3)-P(2,J)*Q(2)-P(1,J)*Q(1)
P3K=P(4,K)*Q(4)-P(3,K)*Q(3)-P(2,K)*Q(2)-P(1,K)*Q(1)
P4K=P(4,L)*Q(4)-P(3,L)*Q(3)-P(2,L)*Q(2)-P(1,L)*Q(1)
KK=Q(4)*Q(4)-Q(3)*Q(3)-Q(2)*Q(2)-Q(1)*Q(1)
LEIC = 0
LEIC = LEIC + P1K*P2K * ( - 4*P12*P13*P15*P25*P34 + 6*
+ P12*P13*P24*P25*P34 - 2*P12*P14*P15*P25*P34 - 2*P12*P14*P24*
+ P25*P34 - 2*P12*P15*P25*P34**2 + 2*P12*P24*P25*P34**2 + 4*P13
+ *P14*P15*P24*P34 - 2*P13*P14*P15*P25*P34 - 3*P13*P14*P23*P24*
+ P25 - P13*P14*P24**2*P25 + P13*P14**2*P15*P24 - 2*P13*P15*P23
+ *P25*P34 + P13*P15*P24*P25*P34 - P13*P15*P24*P34**2 - P13*P15
+ *P25*P34**2 + P13*P23*P24*P25*P34 - 2*P13*P24**2*P25*P34 + 6*
+ P13**2*P14*P15*P24 - P13**2*P23*P24*P25 + P13**2*P24*P25*P34
+ - 3*P13**2*P24**2*P25 + P13**3*P15*P24 - P14*P15*P23*P25*P34
+ - 2*P14*P15*P24*P25*P34 - 2*P14*P15*P25*P34**2 - 3*P14*P23*
+ P24*P25*P34 + P14*P24*P25*P34**2 - 2*P14*P24**2*P25*P34 -
+ P14**2*P15*P25*P34 - P14**2*P24*P25*P34 + P15*P23*P25*P34**2
+ + P15*P24*P25*P34**2 + P15*P25*P34**3 + P24*P25*P34**3 -
+ P24**2*P25*P34**2 )
LEIC = LEIC + P1K*P3K * ( 3*P12*P13*P34 - P12*P14*P34
+ - P12*P34**2 + P13*P14*P24 + 2*P13*P15*P34 - P13**2*P24 -
+ P14*P15*P34 + 3*P14*P24*P34 + P15*P34**2 - 3*P24*P34**2 )
+ *P24*P25
LEIC = LEIC + P1K*P4K * ( - 2*P12*P13*P15*P34 + 3*P12*
+ P13*P24*P34 - P12*P14*P15*P34 - P12*P14*P24*P34 - 3*P12*P15*
+ P34**2 + 3*P12*P24*P34**2 - P13*P14*P23*P24 - P13*P15*P23*P34
+ - 2*P13*P15*P24*P34 - 2*P13*P23*P24*P34 + P13**2*P23*P24 + 2
+ *P14*P15*P23*P34 - 3*P14*P23*P24*P34 + P23*P24*P34**2 )*P25
LEIC = LEIC + P1K**2 * ( 2*P13*P15 - 3*P13*P23 - 3*P13*
+ P24 + P14*P15 + P14*P23 + P14*P24 + 3*P15*P34 + P23*P34 - 3*
+ P24*P34 )*P24*P25*P34
LEIC = LEIC + P2K*P3K * ( - 2*P12*P13*P15*P25*P34 +
+ P12*P13*P24*P25*P34 - P12*P14*P15*P25*P34 - 3*P12*P14*P24*P25
+ *P34 - P12*P15*P25*P34**2 + P12*P24*P25*P34**2 + 2*P13*P14*
+ P15*P24*P34 - P13*P14*P15*P25*P34 - P13*P14*P23*P24*P25 - 2*
+ P13*P14*P24*P25*P34 + P13*P14*P24**2*P25 - 2*P13*P14**2*P15*
+ P24 - 4*P13*P15*P23*P25*P34 - 2*P13*P15*P25*P34**2 + 2*P13**2
+ *P14*P15*P24 - 2*P14*P15*P23*P25*P34 - 3*P14*P15*P24*P25*P34
+ - 2*P14*P15*P25*P34**2 - 3*P14*P23*P24*P25*P34 - P14*P24**2*
+ P25*P34 - P14**2*P24*P25*P34 )
LEIC = LEIC + P2K*P4K * ( - P12*P13*P15*P25*P34 + 2*
+ P12*P13*P24*P25*P34 - 2*P12*P14*P15*P25*P34 - 2*P12*P14*P24*
+ P25*P34 - 2*P12*P24*P25*P34**2 + 4*P13*P14*P15*P24*P34 - P13*
+ P14*P15*P25*P34 + P13*P14*P24*P25*P34 - 2*P13*P15*P23*P25*P34
+ - 3*P13*P15*P24*P25*P34 - P13*P15*P25*P34**2 + 3*P13*P23*P24
+ *P25*P34 - 2*P13*P24*P25*P34**2 + P13*P24**2*P25*P34 + 2*
+ P13**2*P14*P15*P24 - 2*P13**2*P15*P24*P34 + 2*P13**2*P15*P25*
+ P34 + P13**2*P23*P24*P25 - P13**2*P24**2*P25 - 2*P13**3*P15*
+ P24 - 2*P14*P15*P23*P25*P34 - 4*P14*P15*P24*P25*P34 )
LEIC = LEIC + P2K**2 * ( 2*P13*P14*P15 + P13*P14*P24 +
+ P13*P15*P34 - P13*P24*P34 + 2*P13**2*P15 - P13**2*P24 + 2*P14
+ *P15*P34 + 2*P14*P24*P34 + 2*P14**2*P15 + 2*P14**2*P24 )
+ *P25*P34
LEIC = LEIC + P3K*P4K * ( - P12*P13*P15*P34 + 2*P12*
+ P13*P24*P34 - P12*P14*P15*P34 - P12*P15*P34**2 + 2*P12*P24*
+ P34**2 - 2*P13*P14*P23*P24 - 2*P13*P15*P23*P34 - 2*P13*P24**2
+ *P34 - 2*P13**2*P24**2 - 2*P14*P23*P24*P34 )*P25
LEIC = LEIC + P3K**2 * ( 2*P13*P14*P24 + 2*P13*P15*P34
+ + 2*P14*P24*P34 )*P24*P25
LEIC = LEIC + P4K**2 * ( 2*P12*P15*P34 + 2*P13*P23*P24
+ + 2*P23*P24*P34 )*P13*P25
c$$$ LEIC = LEIC + KK * ( - 4*P12*P13*P14*P15*P24*P34 + 4*
c$$$ + P12*P13*P14*P15*P25*P34 + 3*P12*P13*P14*P23*P24*P25 - 2*P12*
c$$$ + P13*P14*P24*P25*P34 + P12*P13*P14*P24**2*P25 - P12*P13*P14**2
c$$$ + *P15*P24 + 4*P12*P13*P15*P23*P25*P34 + P12*P13*P15*P24*P34**2
c$$$ + + 2*P12*P13*P15*P25*P34**2 - 2*P12*P13*P23*P24*P25*P34 - 2*
c$$$ + P12*P13*P24*P25*P34**2 - 6*P12*P13**2*P14*P15*P24 + P12*
c$$$ + P13**2*P23*P24*P25 - 4*P12*P13**2*P24*P25*P34 + 3*P12*P13**2*
c$$$ + P24**2*P25 - P12*P13**3*P15*P24 + 2*P12*P14*P15*P23*P25*P34
c$$$ + + 4*P12*P14*P15*P24*P25*P34 + 5*P12*P14*P15*P25*P34**2 + 6*
c$$$ + P12*P14*P23*P24*P25*P34 + P12*P14*P24*P25*P34**2 + 4*P12*P14*
c$$$ + P24**2*P25*P34 + 2*P12*P14**2*P15*P25*P34 + 2*P12*P14**2*P24*
c$$$ + P25*P34 - P12*P15*P24*P25*P34**2 + P12*P15*P25*P34**3 - P12*
c$$$ + P23*P24*P25*P34**2 + 3*P12*P24**2*P25*P34**2 + 4*P12**2*P13*
c$$$ + P15*P25*P34 - 6*P12**2*P13*P24*P25*P34 + 2*P12**2*P14*P15*P25
c$$$ + *P34 + 2*P12**2*P14*P24*P25*P34 + 2*P12**2*P15*P25*P34**2 - 2
c$$$ + *P12**2*P24*P25*P34**2 )/4
c$$$ LEIC = LEIC + KK * ( - 2*P13*P14*P15*P23*P24*P34 + 2*
c$$$ + P13*P14*P15*P23*P25*P34 + P13*P14*P15*P24*P25*P34 - 4*P13*P14
c$$$ + *P15*P24**2*P34 + 3*P13*P14*P23*P24*P25*P34 - P13*P14*P23*
c$$$ + P24**2*P25 + P13*P14*P23**2*P24*P25 - 3*P13*P14*P24**2*P25*
c$$$ + P34 + 2*P13*P14**2*P15*P23*P24 + P13*P14**2*P23*P24*P25 + 2*
c$$$ + P13*P15*P23*P24*P25*P34 + 4*P13*P15*P23*P25*P34**2 + 4*P13*
c$$$ + P15*P23**2*P25*P34 - P13*P15*P24*P25*P34**2 + 3*P13*P15*
c$$$ + P24**2*P25*P34 - 3*P13*P23*P24**2*P25*P34 + 2*P13*P24**2*P25*
c$$$ + P34**2 - P13*P24**3*P25*P34 - 2*P13**2*P14*P15*P23*P24 - 2*
c$$$ + P13**2*P14*P15*P24**2 - P13**2*P14*P23*P24*P25 - P13**2*P14*
c$$$ + P24**2*P25 - 2*P13**2*P15*P24*P25*P34 + 2*P13**2*P15*P24**2*
c$$$ + P34 - P13**2*P23*P24**2*P25 + P13**2*P24**2*P25*P34 + P13**2*
c$$$ + P24**3*P25 + 2*P13**3*P15*P24**2 + P13**3*P24**2*P25 + 5*P14*
c$$$ + P15*P23*P24*P25*P34 + P14*P15*P23*P25*P34**2 + 2*P14*P15*
c$$$ + P23**2*P25*P34 + 4*P14*P15*P24**2*P25*P34 + 2*P14*P23*P24*P25
c$$$ + *P34**2 + )/4
c$$$ LEIC = LEIC + KK * ( P14*P23*P24**2*P25*P34 + 3*P14*
c$$$ + P23**2*P24*P25*P34 - P14**2*P15*P23*P25*P34 + 3*P14**2*P23*
c$$$ + P24*P25*P34 )/4
LEIC = LEIC/(2*P15*P25**2*P13*P34**2*P24)
END
C-----------------------------------------------------------------------
FUNCTION LEID(P,Q,II,JJ,KKK,LL)
IMPLICIT NONE
C---EVALUATE THE MATRIX ELEMENT CONTRACTED WITH A TENSOR -Q(MU)Q(NU)
C WITH P(*,I)=P1, P(*,J)=P2, ETC
INTEGER I,J,K,L,II,JJ,KKK,LL
DOUBLE PRECISION LEID,P(4,7),Q(4),DOT,
$ P12,P13,P14,P23,P24,P34,P15,P25,P35,P45,Q2,
$ P1K,P2K,P3K,P4K,KK
C---CONVERT FROM ERT NOTATION (Q'QQ'BARQBAR) TO LEIDEN (QQBARQ'BARQ')
I=JJ
J=LL
K=KKK
L=II
P12=2*DOT(P,I,J)
P13=2*DOT(P,I,K)
P14=2*DOT(P,I,L)
P23=2*DOT(P,J,K)
P24=2*DOT(P,J,L)
P34=2*DOT(P,K,L)
P15=P23+P24+P34
P25=P13+P14+P34
P35=P12+P14+P24
P45=P12+P13+P23
Q2=P12+P13+P14+P23+P24+P34
P1K=P(4,I)*Q(4)-P(3,I)*Q(3)-P(2,I)*Q(2)-P(1,I)*Q(1)
P2K=P(4,J)*Q(4)-P(3,J)*Q(3)-P(2,J)*Q(2)-P(1,J)*Q(1)
P3K=P(4,K)*Q(4)-P(3,K)*Q(3)-P(2,K)*Q(2)-P(1,K)*Q(1)
P4K=P(4,L)*Q(4)-P(3,L)*Q(3)-P(2,L)*Q(2)-P(1,L)*Q(1)
KK=Q(4)*Q(4)-Q(3)*Q(3)-Q(2)*Q(2)-Q(1)*Q(1)
LEID = 0
LEID = LEID + P1K*P2K * ( - 2*P12*P25*P34 - 4*P13*P14*
+ P15 - 2*P13*P15*P34 + 2*P13*P24*P25 - 2*P14*P15*P34 + 2*P14*
+ P23*P25 )/P25
LEID = LEID + P1K*P3K * ( - P12*P34 - 2*P14*P24 + P24*P25 )
LEID = LEID + P1K*P4K * ( - P12*P34 - 2*P13*P23 + P23*P25 )
LEID = LEID + P1K**2 * ( P23 + P24 )*P34
LEID = LEID + P2K*P3K * ( - P12*P25*P34 - 4*P13*P14*P15
+ - 2*P13*P15*P34 + 3*P14*P15*P25 - 2*P14*P15*P34 - 2*P14*P24*
+ P25 )/P25
LEID = LEID + P2K*P4K * ( - P12*P25*P34 - 4*P13*P14*P15
+ + 3*P13*P15*P25 - 2*P13*P15*P34 - 2*P13*P23*P25 - 2*P14*P15*
+ P34 )/P25
LEID = LEID + P2K**2 * ( P13 + P14 )*P34
LEID = LEID + P3K*P4K * ( - 2*P12*P34 + 2*P13*P24 + 2*
+ P14*P23 )
LEID = LEID + P3K**2 * ( - 2*P14*P24 )
LEID = LEID + P4K**2 * ( - 2*P13*P23 )
c$$$ LEID = LEID + KK * ( Q2*P12*P25*P34 - Q2*P13*P24*P25
c$$$ + - Q2*P14*P23*P25 + 2*P12*P13*P15*P25 - P12*P13*P24*P25 - 2
c$$$ + *P12*P13**2*P15 + 2*P12*P14*P15*P25 - P12*P14*P23*P25 - 2*P12
c$$$ + *P14**2*P15 + P12*P25*P34**2 + P12**2*P25*P34 + 2*P13*P14*P23
c$$$ + *P25 + 2*P13*P14*P24*P25 + 2*P13*P15*P23*P25 + 2*P13*P23*P24*
c$$$ + P25 - P13*P24*P25*P34 - 2*P13**2*P15*P23 - 2*P13**2*P15*P24
c$$$ + + 2*P14*P15*P24*P25 + 2*P14*P23*P24*P25 - P14*P23*P25*P34 -
c$$$ + 2*P14**2*P15*P23 - 2*P14**2*P15*P24 )/(4*P25)
LEID = LEID/(P15*P25*P34**2)
END
C-----------------------------------------------------------------------
FUNCTION LEIE(P,Q,II,JJ,KKK,LL)
IMPLICIT NONE
C---EVALUATE THE MATRIX ELEMENT CONTRACTED WITH A TENSOR -Q(MU)Q(NU)
C WITH P(*,I)=P1, P(*,J)=P2, ETC
INTEGER I,J,K,L,II,JJ,KKK,LL
DOUBLE PRECISION LEIE,P(4,7),Q(4),DOT,
$ P12,P13,P14,P23,P24,P34,P15,P25,P35,P45,Q2,
$ P1K,P2K,P3K,P4K,KK
C---CONVERT FROM ERT NOTATION (Q'QQ'BARQBAR) TO LEIDEN (QQBARQ'BARQ')
I=JJ
J=LL
K=KKK
L=II
P12=2*DOT(P,I,J)
P13=2*DOT(P,I,K)
P14=2*DOT(P,I,L)
P23=2*DOT(P,J,K)
P24=2*DOT(P,J,L)
P34=2*DOT(P,K,L)
P15=P23+P24+P34
P25=P13+P14+P34
P35=P12+P14+P24
P45=P12+P13+P23
Q2=P12+P13+P14+P23+P24+P34
P1K=P(4,I)*Q(4)-P(3,I)*Q(3)-P(2,I)*Q(2)-P(1,I)*Q(1)
P2K=P(4,J)*Q(4)-P(3,J)*Q(3)-P(2,J)*Q(2)-P(1,J)*Q(1)
P3K=P(4,K)*Q(4)-P(3,K)*Q(3)-P(2,K)*Q(2)-P(1,K)*Q(1)
P4K=P(4,L)*Q(4)-P(3,L)*Q(3)-P(2,L)*Q(2)-P(1,L)*Q(1)
KK=Q(4)*Q(4)-Q(3)*Q(3)-Q(2)*Q(2)-Q(1)*Q(1)
LEIE = 0
LEIE = LEIE + P1K*P2K * ( - 2*Q2*P13*P15*P25 + Q2*
+ P23*P25**2 + 2*P13*P14*P15*P25 - 4*P14*P15*P25*P45 - P14*P23*
+ P25**2 + 2*P14**2*P15*P45 - 2*P15*P23*P25*P34 + 2*P15*P25**2*
+ P45 - P23*P25**2*P45 )/(P13*P25*P45)
LEIE = LEIE + P1K*P3K * ( - 2*Q2*P13*P15 + Q2*P23*
+ P25 - 2*P12*P14*P15 - P14*P23*P25 - 2*P15*P23*P34 + 2*P15*P25
+ *P45 - P23*P25*P45 )/(P13*P45)
LEIE = LEIE + P1K*P4K * ( 2*Q2*P25 + 2*P13*P15 - 2*P14*
+ P25 - 2*P15*P25 - 2*P15*P34 - 2*P25*P45 )*P23/(P13*P45)
LEIE = LEIE + P1K**2 * ( - 2*P15*P23*P34 )/(P13*P45)
LEIE = LEIE + P2K*P3K * ( - 2*P12*P15*P25 + 2*P13*P15*
+ P25 + 2*P14*P15*P45 - 2*P23*P25**2 )*P14/(P13*P25*P45)
LEIE = LEIE + P2K*P4K * ( Q2*P23*P25**2 + 2*P12*P15*P25
+ *P34 - 2*P13*P15*P24*P25 + 2*P14*P15*P23*P25 - 2*P14*P15*P25*
+ P45 - P14*P23*P25**2 + 2*P14**2*P15*P45 - P15*P23*P25**2 )
+ /(P13*P25*P45)
LEIE = LEIE + P2K**2 * ( 2*P13*P15 - P23*P25 )*P14/(P13*P45)
LEIE = LEIE + P3K*P4K * ( - 2*Q2*P13*P15 + Q2*P23*
+ P25 - 2*P12*P14*P15 + 2*P13*P15*P23 - P14*P23*P25 - 3*P15*P23
+ *P25 + 2*P15*P25*P45 )/(P13*P45)
LEIE = LEIE + P3K**2 * ( - 2*P12*P15 - P23*P25 )*P14/(P13*P45)
LEIE = LEIE + P4K**2 * ( 2*P15*P23 )/P45
c$$$ LEIE = LEIE + KK * ( Q2*P13*P15*P24*P25 + Q2*P14*P23*
c$$$ + P25**2 - Q2*P14**2*P15*P45 + Q2*P15*P23*P25**2 + Q2*P23
c$$$ + *P25**2*P45 - Q2**2*P23*P25**2 - P12*P13*P15*P25*P34 + P12
c$$$ + *P14*P15*P23*P25 - P12*P15*P24*P25*P34 - P12*P15*P25*P34**2 -
c$$$ + P12**2*P15*P25*P34 - P13*P14*P15*P23*P25 - P13*P14*P15*P24*
c$$$ + P25 - P13*P15*P23*P24*P25 - P14*P15*P23*P24*P25 + P14*P15*P23
c$$$ + *P25*P34 + P14*P15*P25*P35*P45 - P15*P23*P25**2*P45 )
c$$$ + /(2*P13*P25*P45)
LEIE = LEIE/(P15*P25*P34)
END
C-----------------------------------------------------------------------
SUBROUTINE WARNER(SUBR,TYPE,*)
IMPLICIT NONE
C---GIVE WARNING MESSAGES ABOUT NUMERICAL ERRORS
INTEGER TYPE
LOGICAL FIRST
CHARACTER*(*) SUBR
INTEGER METYPE,NF
DOUBLE PRECISION CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF
COMMON /CONCOM/ CF,CA,TR,PI,PISQ,HF,CUTOFF,CUTUP,CQ,FPAL2,ONF,
$ NF,METYPE
DATA FIRST/.TRUE./
WRITE (*,'(A,I2,3A)')
$' Numerical error of type',TYPE,' in routine ',SUBR,'!'
IF (FIRST) THEN
WRITE (*,'(/A)')
$' This should be preventable by increasing the internal variable'
WRITE (*,'(A,1PE8.1,A)')
$' CUTOFF, whose present value is',CUTOFF,'. If this fails to'
WRITE (*,'(A)')
$' reduce the frequency of errors, something is probably more'
WRITE (*,'(A)')
$' seriously wrong, so please contact seymour@surya11.cern.ch'
WRITE (*,'(A)')
$' giving the date of this version and the latest value of ISEED.'
WRITE (*,'(A/)') ' Event generation has not been affected.'
FIRST=.FALSE.
ENDIF
RETURN 1
END
C-----------------------------------------------------------------------
C-----------------------------------------------------------------------
C-----------------------------------------------------------------------
subroutine convert(p)
implicit none
integer i,j
double precision p(4,7),plab
common /mom/ plab(4,10)
do j=1,4
do i=1,4
plab(j,i+2)=p(j,i)
enddo
plab(j,1)=p(j,7)
plab(j,2)=p(j,6)
enddo
end
C-----------------------------------------------------------------------
subroutine setup
implicit double precision(a-h,o-z)
parameter(pi=3.141592653589793238D0)
common /inppar/ njets,nloop,itmax1,itmax2,nshot1,nshot2,nshot3
common /zcup/czur,czul,czdr,czdl,czlr,czll,cznr,cznl
common /gcup/cgur,cgul,cgdr,cgdl,cglr,cgll,cgnr,cgnl
common /genera/ w,em,sw2,rmz,rgz,nutf,ndtf,icon
common /strong/ as,gs,renscl,qcdl,b0,nf
common /sighad/ sig0
common /order/iorder
common /tcuts/ ymin,dly
common /ecuts/ ycut,evis,jetalg
common /polar/ Peleft,Ppright
character*4 alg
logical done
data done/.false./
if (done) return
done=.true.
c---set the general parameters
rmz=91.17D0
rgz=2.516D0
w=0
c---set the polarisations
Peleft=0.5
Ppright=0.5
c---and a few other parameters
ymin=1D-8
as=2*pi
c
c iorder determines whether we keep all terms, or leading N, subleading N
c or nf pieces
c iorder=0 all, iorder=1, leading N, iorder=2 1/N**2, iorder=3 nf
c
iorder=0
c
c icon determines which interference terms to use
c icon=0 all, icon=1 gives gg, icon=2 gives gz, icon=3 gives zz
c
icon=1
c
c check that matrix elements vanish when pz is contracted in : momcon=1
c
momcon=0
c
c physics parameters:
c
c nutf : number of up type flavours
c ndtf : number of down type flavours
nutf=2
ndtf=3
nf=nutf+ndtf
if(iorder.eq.0)b0=(33D0-2D0*nf)/12D0/pi
if(iorder.eq.1)b0=33D0/12D0/pi
if(iorder.eq.2)b0=0D0
if(iorder.eq.3)b0=-2D0*nf/12D0/pi
c
c renscl : scale at which alpha_s is evaluated = scl* rmz
c can adjust alpha_s by changing scl or qcdl below
c
scl=1D0
renscl=scl*rmz
dly=log(ymin)
c
c qcdl : two loop lambda qcd for 4 flavours
c
qcdl=0.200D0
alfa=alfas(renscl,qcdl,2)
gs=sqrt(4.D0*pi*as)
am=1.D0/128D0
em=sqrt(4.D0*pi*am)
sw2=0.23D0
c determine the width of the z
scw=sqrt(sw2)*sqrt(1D0-sw2)
cgll=-1D0
cglr=-1D0
cgnl=0D0
cgnr=0D0
cgur=+2D0/3D0
cgdr=-1D0/3D0
cgul=+2D0/3D0
cgdl=-1D0/3D0
czll=(-0.5D0+sw2)/scw
czlr=sw2/scw
cznl=0.5D0/scw
cznr=0D0
czul=(+0.5D0-sw2*2D0/3D0)/scw
czur=(-sw2*2D0/3D0)/scw
czdl=(-0.5D0+sw2*1D0/3D0)/scw
czdr=(+sw2*1D0/3D0)/scw
c calculate the width of the z ( no top quark! )
rgee= em**2*(czll**2+czlr**2)*rmz/24.D0/pi
rgnn= em**2*(cznl**2+cznr**2)*rmz/24.D0/pi
rguu= 3D0*em**2*(czul**2+czur**2)*rmz/24.D0/pi
rgdd= 3D0*em**2*(czdl**2+czdr**2)*rmz/24.D0/pi
rglep= 3D0*rgee
rginv= 3D0*rgnn
rghad= (1D0+(alfa/pi)+1.41*(alfa/pi)**2)*(2D0*rguu+3D0*rgdd)
rghad= (2D0*rguu+3D0*rgdd)
rgz0 = rglep + rginv + rghad
rgz1 = rglep + rginv + rghad*(1D0+(alfa/pi))
rgz2 = rglep + rginv + rghad*(1D0+(alfa/pi)+1.41*(alfa/pi)**2)
* test=abs((rgztest-rgz)/rgz*100D0)
* write(*,40)rgz0
40 format(/,'lowest order z boson width = ',f6.3,' GeV ')
* write(*,41)rgz1
41 format(/,' first order z boson width = ',f6.3,' GeV ')
* write(*,42)rgz2
42 format(/,'second order z boson width = ',f6.3,' GeV ')
wtnano=389385.73D0
c
c hadronic cross section
c
sig0=wtnano*rghad*rgee*12D0*pi/rmz**2/rgz**2
if(jetalg.eq.1)alg=' E '
if(jetalg.eq.2)alg=' E0 '
if(jetalg.eq.3)alg=' P '
if(jetalg.eq.4)alg=' P0 '
if(jetalg.eq.5)alg=' D '
if(jetalg.eq.6)alg=' DE '
if(jetalg.eq.7)alg=' DP '
if(jetalg.eq.8)alg=' D1 '
write(*,*) '*************************************************',
. '*****************'
write(*,*)' ',
. ' prelim 13/6/94 '
write(*,11)njets,(njets-2+nloop),w
11 format(/,' e+e- to ',i2,' jets at O(alphas**',i1,') at ',
. ' root s = ',f7.2, ' GeV ')
if(iorder.eq.0)write(*,*)' including all colour pieces'
if(iorder.eq.1)write(*,*)' including only leading colour pieces'
if(iorder.eq.2)write(*,*)' including only subleading ',
. 'colour pieces'
if(iorder.eq.3)write(*,*)' including only nf pieces'
if(icon.eq.0)write(*,*)' including both photon and z exchange'
if(icon.eq.1)write(*,*)' including only photon exchange'
if(icon.eq.2)write(*,*)' including photon - z interference'
if(icon.eq.3)write(*,*)' including only z exchange'
if(momcon.eq.1)write(*,*)' checking momentum conservation => 0'
write(*,12)as
12 format(/,' alphas(Mz) = ',f8.4)
write(*,13)4D0*pi/em**2,sw2
13 format(/,' 1/alpha = ',f7.2,'; sin**2 theta = ',f6.3)
write(*,14)sig0
14 format(/,' sigma(hadronic) = ',f8.3,' nb')
write(*,15)alg,ycut
15 format(/,' with jets defined in',a3,'-scheme with ycut = ',f8.4)
write(*,16)rmz,rgz
16 format(/,' Z mass = ',f6.3,' GeV, Z width = ',f6.3,' GeV')
write(*,17)Peleft*100D0
17 format(/,' electron beam = ',f4.1,'% left handed')
write(*,18)Ppright*100D0
18 format(/,' positron beam = ',f4.1,'% right handed')
write(*,19)ymin
19 format(/,' parton resolution parameter = ',g12.5)
write(*,20)itmax1,nshot1/10,nshot2/10,nshot3/10
20 format(/,' warm up with ',i6,' sweeps of ',3i9,' shots ')
write(*,21)itmax2,nshot1,nshot2,nshot3
21 format(/,' final run of ',i6,' sweeps of ',3i9,' shots ')
write(*,*) '*************************************************',
. '*****************'
return
end
c***********************************************************************
c
c compute matrix element weight using library
c
subroutine sfmee(npar,nloop,eetot)
c***********************************************************************
implicit double precision (a-h,o-y)
implicit complex*16(z)
common /genera/ w,em,sw2,rmz,rgz,nutf,ndtf,icon
common /result/eeggl,eegzl,eezzl,eeggr,eegzr,eezzr,eetotl,eetotr
common /polar/ Peleft,Ppright
common /mom/ plab(4,10)
common /kinema/ p(4,7)
common /dotpr/ zud(7,7),zd(7,7),zko(7,2),zkod(7,2),negaen
common /linpr/ rin(7,7)
common /curent/ zrcur(2,2),zlcur(2,2)
common /check/ momcon
c
c transform vectors - all momenta outgoing
do 10 mu=1,4
do 5 n=1,npar
p(mu,n)=plab(mu,n+2)
5 continue
p(mu,6)=-plab(mu,1)
p(mu,7)=-plab(mu,2)
10 continue
c
c initialise the spinor and dot products
call setspn(npar)
c all quarks have positive energy so
negaen=1
c
c initialise the lepton current
do 20 ia=1,2
do 20 ib=1,2
if(momcon.eq.0)then
zrcur(ia,ib)=zkod(6,ia)*zko(7,ib)
elseif(momcon.eq.1)then
zrcur(ia,ib)=(0D0,0D0)
do 15 ipar=1,npar+1
zrcur(ia,ib)=zrcur(ia,ib)+zkod(ipar,ia)*zko(ipar,ib)
15 continue
endif
zlcur(ib,ia)=conjg(zrcur(ia,ib))
20 continue
c
if(npar.eq.2) call sfee2j(nloop,eetot)
if(npar.eq.3) call sfee3j(nloop,eetot)
if(npar.eq.4) call sfee4j(nloop,eetot)
c
if(icon.eq.1)eetot=Peleft*Ppright*eeggl
. +(1D0-Peleft)*(1D0-Ppright)*eeggr
if(icon.eq.2)eetot=Peleft*Ppright*eegzl
. +(1D0-Peleft)*(1D0-Ppright)*eegzr
if(icon.eq.3)eetot=Peleft*Ppright*eezzl
. +(1D0-Peleft)*(1D0-Ppright)*eezzr
c
return
end
***********************************************************************
c sfee2j calculates the process e+ e- --> g,z --> q + qb
c includes: no spin averages, final state statistics, couplings
c**********************************************************************
subroutine sfee2j(nloop,eetot)
implicit double precision(a-h,o-y)
implicit complex*16(z)
common /genera/ w,em,sw2,rmz,rgz,nutf,ndtf,icon
common /strong/ as,gs,renscl,qcdl,b0,nf
common /result/eeggl,eegzl,eezzl,eeggr,eegzr,eezzr,eetotl,eetotr
common /polar/ Peleft,Ppright
dimension rl(3,2),rr(3,2)
dimension zhl(3,2),zhr(3,2)
c
call eeq2gn(0,nloop,rl(1,1),rr(1,1),zhl,zhr,rmz,rgz)
c
factor=em**4
c
eeggl=(nutf*rl(1,1)+ndtf*rl(1,2))*factor
eegzl=(nutf*rl(2,1)+ndtf*rl(2,2))*factor
eezzl=(nutf*rl(3,1)+ndtf*rl(3,2))*factor
eeggr=(nutf*rr(1,1)+ndtf*rr(1,2))*factor
eegzr=(nutf*rr(2,1)+ndtf*rr(2,2))*factor
eezzr=(nutf*rr(3,1)+ndtf*rr(3,2))*factor
eetotl=eeggl+eegzl+eezzl
eetotr=eeggr+eegzr+eezzr
eetot=Peleft*Ppright*eetotl
. +(1D0-Peleft)*(1D0-Ppright)*eetotr
end
c
c**********************************************************************
c sfee3j calculates the process e+ e- --> g,z --> q + qb + g
c includes: no spin averages, final state statistics, couplings
c**********************************************************************
subroutine sfee3j(nloop,eetot)
implicit double precision(a-h,o-y)
implicit complex*16(z)
common /genera/ w,em,sw2,rmz,rgz,nutf,ndtf,icon
common /strong/ as,gs,renscl,qcdl,b0,nf
common /result/eeggl,eegzl,eezzl,eeggr,eegzr,eezzr,eetotl,eetotr
common /reshel/zeegghl,zeegzhl,zeezzhl,zeegghr,zeegzhr,
$ zeezzhr,zeetohl,zeetohr,zeetoh
common /polar/ Peleft,Ppright
dimension rl(3,2),rr(3,2)
dimension zhl(3,2),zhr(3,2)
c
call eeq2gn(1,nloop,rl(1,1),rr(1,1),zhl,zhr,rmz,rgz)
c
factor=em**4*gs**2
c
eeggl=(nutf*rl(1,1)+ndtf*rl(1,2))*factor
eegzl=(nutf*rl(2,1)+ndtf*rl(2,2))*factor
eezzl=(nutf*rl(3,1)+ndtf*rl(3,2))*factor
eeggr=(nutf*rr(1,1)+ndtf*rr(1,2))*factor
eegzr=(nutf*rr(2,1)+ndtf*rr(2,2))*factor
eezzr=(nutf*rr(3,1)+ndtf*rr(3,2))*factor
eetotl=eeggl+eegzl+eezzl
eetotr=eeggr+eegzr+eezzr
eetot=Peleft*Ppright*eetotl
. +(1D0-Peleft)*(1D0-Ppright)*eetotr
c---also apply the appropriate factors to the gluon helicity amplitudes
if (nloop.eq.0) then
zeegghl=(nutf*zhl(1,1)+ndtf*zhl(1,2))*factor
zeegzhl=(nutf*zhl(2,1)+ndtf*zhl(2,2))*factor
zeezzhl=(nutf*zhl(3,1)+ndtf*zhl(3,2))*factor
zeegghr=(nutf*zhr(1,1)+ndtf*zhr(1,2))*factor
zeegzhr=(nutf*zhr(2,1)+ndtf*zhr(2,2))*factor
zeezzhr=(nutf*zhr(3,1)+ndtf*zhr(3,2))*factor
zeetohl=zeegghl+zeegzhl+zeezzhl
zeetohr=zeegghr+zeegzhr+zeezzhr
if(icon.eq.1) then
zeetoh=Peleft*Ppright*zeegghl
. +(1D0-Peleft)*(1D0-Ppright)*zeegghr
elseif(icon.eq.2) then
zeetoh=Peleft*Ppright*zeegzhl
. +(1D0-Peleft)*(1D0-Ppright)*zeegzhr
elseif(icon.eq.3) then
zeetoh=Peleft*Ppright*zeezzhl
. +(1D0-Peleft)*(1D0-Ppright)*zeezzhr
else
zeetoh=Peleft*Ppright*zeetohl
. +(1D0-Peleft)*(1D0-Ppright)*zeetohr
endif
endif
end
c
c**********************************************************************
c sfee4j calculates the process e+ e- --> g,z --> q + qb + ( gg or qqb)
c includes: no spin averages, final state statistics, couplings
c**********************************************************************
subroutine sfee4j(nloop,eetot)
implicit double precision(a-h,o-y)
implicit complex*16(z)
common /genera/ w,em,sw2,rmz,rgz,nutf,ndtf,icon
common /strong/ as,gs,renscl,qcdl,b0,nf
common /result/eeggl,eegzl,eezzl,eeggr,eegzr,eezzr,eetotl,eetotr
common /polar/ Peleft,Ppright
dimension rggl(3,2),rggr(3,2),rqql(3,5),rqqr(3,5)
dimension zhl(3,2),zhr(3,2)
common /order/iorder
common /perm/ips
c
do i=1,3
do j=1,5
rqql(i,j)=0D0
rqqr(i,j)=0D0
enddo
do k=1,2
rggl(i,k)=0D0
rggr(i,k)=0D0
enddo
enddo
sum=1
if(ips.eq.1)then
if(iorder.eq.0)then
call eeq2gn(2,nloop,rggl(1,1),rggr(1,1),zhl,zhr,rmz,rgz)
call eeq4(rqql(1,1),rqqr(1,1),rmz,rgz,1,3,2,4)
call eeq4(rqql(1,1),rqqr(1,1),rmz,rgz,2,4,1,3)
sum=2
elseif(iorder.eq.1)then
call eeq2gn(2,nloop,rggl(1,1),rggr(1,1),zhl,zhr,rmz,rgz)
elseif(iorder.eq.3)then
call eeq4(rqql(1,1),rqqr(1,1),rmz,rgz,1,3,2,4)
call eeq4(rqql(1,1),rqqr(1,1),rmz,rgz,2,4,1,3)
sum=2
endif
elseif(ips.eq.2)then
if(iorder.eq.0.or.iorder.eq.2)then
call eeq2gn(2,nloop,rggl(1,1),rggr(1,1),zhl,zhr,rmz,rgz)
endif
endif
c
factor=em**4*gs**4
c
eeggl=(+nutf*rggl(1,1)/2D0+ndtf*rggl(1,2)/2D0
. +nutf*rqql(1,1)/4D0/sum+ndtf*rqql(1,2)/4D0/sum
. +0.5D0*nutf*(nutf-1)*rqql(1,3)/sum
. +0.5D0*ndtf*(ndtf-1)*rqql(1,4)/sum
. +nutf*ndtf*rqql(1,5)/sum)*factor
eegzl=(+nutf*rggl(2,1)/2D0+ndtf*rggl(2,2)/2D0
. +nutf*rqql(2,1)/4D0/sum+ndtf*rqql(2,2)/4D0/sum
. +0.5D0*nutf*(nutf-1)*rqql(2,3)/sum
. +0.5D0*ndtf*(ndtf-1)*rqql(2,4)/sum
. +nutf*ndtf*rqql(2,5)/sum)*factor
eezzl=(+nutf*rggl(3,1)/2D0+ndtf*rggl(3,2)/2D0
. +nutf*rqql(3,1)/4D0/sum+ndtf*rqql(3,2)/4D0/sum
. +0.5D0*nutf*(nutf-1)*rqql(3,3)/sum
. +0.5D0*ndtf*(ndtf-1)*rqql(3,4)/sum
. +nutf*ndtf*rqql(3,5)/sum)*factor
eeggr=(+nutf*rggr(1,1)/2D0+ndtf*rggr(1,2)/2D0
. +nutf*rqqr(1,1)/4D0/sum+ndtf*rqqr(1,2)/4D0/sum
. +0.5D0*nutf*(nutf-1)*rqqr(1,3)/sum
. +0.5D0*ndtf*(ndtf-1)*rqqr(1,4)/sum
. +nutf*ndtf*rqqr(1,5)/sum)*factor
eegzr=(+nutf*rggr(2,1)/2D0+ndtf*rggr(2,2)/2D0
. +nutf*rqqr(2,1)/4D0/sum+ndtf*rqqr(2,2)/4D0/sum
. +0.5D0*nutf*(nutf-1)*rqqr(2,3)/sum
. +0.5D0*ndtf*(ndtf-1)*rqqr(2,4)/sum
. +nutf*ndtf*rqqr(2,5)/sum)*factor
eezzr=(+nutf*rggr(3,1)/2D0+ndtf*rggr(3,2)/2D0
. +nutf*rqqr(3,1)/4D0/sum+ndtf*rqqr(3,2)/4D0/sum
. +0.5D0*nutf*(nutf-1)*rqqr(3,3)/sum
. +0.5D0*ndtf*(ndtf-1)*rqqr(3,4)/sum
. +nutf*ndtf*rqqr(3,5)/sum)*factor
eetotl=eeggl+eegzl+eezzl
eetotr=eeggr+eegzr+eezzr
eetot=Peleft*Ppright*eetotl
. +(1D0-Peleft)*(1D0-Ppright)*eetotr
end
c
c**********************************************************************
c matrix element for: e+ e- --> g,z --> q qb + n gluons
c**********************************************************************
c information: the particles in plab are ordered as follows:
c 1,2 incoming particles 1: e+ and 2: e-
c 3,4 quark and anti-quark
c 5,.., 4+n gluons in final state.
c**********************************************************************
c output: the matrix elements for the subprocesses returned in
c left-handed contribution
c rl(3,2): first index are mixings ==> 1: gg 2: gz 3: zz
c second index are flavours ==> 1: u-type, 2: d-type.
c right-handed contribution
c rr(3,2): first index are mixings ==> 1: gg 2: gz 3: zz
c second index are flavours ==> 1: u-type, 2: d-type.
c not included: strong coupling constants!
c statistics, spin averages.
c**********************************************************************
c literature:
c lowest order : berends, giele & kuijf, np 321, 595, 1989
c next to lowest order : giele & glover, prd 46, 1980, 1992
c**********************************************************************
c function eeq2gn(n,nloop,rl,rr,rmz,rgz) calculates the matrix element
c squared of: e+ e- --> g,z --> q + qb + n gluons
c the input vectors are in /kinema/ p(4,7), where the sixth
c and seventh vectors are the e- and the e+ outgoing!.
c the first and second are the quark and the anti-quark.
c**********************************************************************
subroutine eeq2gn(n,nloop,rl,rr,zhl,zhr,rmz,rgz)
implicit double precision(a-h,o-y)
implicit complex*16(z)
common /esadb/ zsadb(2,2,2,4)
common /curent/ zrcur(2,2),zlcur(2,2)
common /dotpr/ zud(7,7),zd(7,7),zko(7,2),zkod(7,2),negaen
common /linpr/ rin(7,7)
common /tcuts/ ymin,dly
common /strong/ as,gs,renscl,qcdl,b0,nf
common /zcup/czur,czul,czdr,czdl,czlr,czll,cznr,cznl
common /gcup/cgur,cgul,cgdr,cgdl,cglr,cgll,cgnr,cgnl
common /order/iorder
common /perm/ips
parameter(pi=3.141592653589793238D0)
dimension col(2,2,0:2)
dimension rl(3,2),rr(3,2)
dimension zhl(3,2),zhr(3,2)
dimension zrr(2,4),zrl(2,4),zlr(2,4),zll(2,4)
dimension z1rr(2,4),z1rl(2,4),z1lr(2,4),z1ll(2,4)
dimension zrsadb(2,2,2,4),zlsadb(2,2,2,4)
dimension zr1adb(2,2,2,4),zl1adb(2,2,2,4)
col(1,1,0)=3D0
col(1,2,0)=0D0
col(2,1,0)=0D0
col(2,2,0)=0D0
col(1,1,1)=4D0
col(1,2,1)=0D0
col(2,1,1)=0D0
col(2,2,1)=0D0
*
if(ips.eq.1)then
if(iorder.eq.0.or.iorder.eq.1)then
c$$$ c2a=12D0
C---THIS MODIFICATION SENT BY NIGEL GLOVER TO AVOID SUMMING OVER PERMS
c2a=6D0
c2b=0D0
endif
elseif(ips.eq.2)then
if(iorder.eq.0.or.iorder.eq.2)then
c2a=-2D0/3D0
c2b=c2a
endif
endif
c$$$ col(1,1,2)=c2b
C---THIS MODIFICATION SENT BY NIGEL GLOVER TO AVOID SUMMING OVER PERMS
col(1,1,2)=c2a
col(1,2,2)=c2b
col(2,1,2)=c2b
col(2,2,2)=c2a
c
s=2D0*rin(6,7)
zprg=(0D0,-1D0)/s
zprz=(0D0,-1D0)/(s-rmz**2+(0D0,1D0)*rgz*rmz)
c
if (n.eq.0) then
factor=1D0
ihel=1
iperm=1
do 6 ia=1,2
do 6 ib=1,2
zrsadb(ia,ib,1,1)=zkod(1,ia)*zko(2,ib)
zlsadb(ib,ia,1,1)=conjg(zrsadb(ia,ib,1,1))
6 continue
endif
c
if (n.eq.1) then
factor=2D0
ihel=2
iperm=1
do 7 ia=1,2
do 7 ib=1,2
zrsadb(ia,ib,1,1)=+(zkod(1,ia)*zud(1,2)
. +zkod(3,ia)*zud(3,2))*zko(2,ib)/(zud(1,3)*zud(3,2))
zrsadb(ia,ib,1,2)=-zkod(1,ia)*(zko(3,ib)*zd(3,1)
. +zko(2,ib)*zd(2,1))/(zd(1,3)*zd(3,2))
zlsadb(ib,ia,1,1)=conjg(zrsadb(ia,ib,1,1))
zlsadb(ib,ia,1,2)=conjg(zrsadb(ia,ib,1,2))
7 continue
if(nloop.eq.1)then
call ert(1,2,3,alp,bep,gap,dep)
call ert(2,1,3,alm,bem,gam,dem)
do 17 ia=1,2
do 17 ib=1,2
zr1adb(ia,ib,1,1)=
. +alp*zkod(1,ia)*zud(1,2)*zko(2,ib)/(zud(1,3)*zud(3,2))
. +bep*zkod(3,ia)*zud(3,2)*zko(2,ib)/(zud(1,3)*zud(3,2))
. +gap*zkod(3,ia)*zd(1,3)*zko(1,ib)/(zud(1,3)*zd(3,2))
. +dep*zd(1,3)/(zud(1,3)*zd(2,1))
. *(zkod(1,ia)*zko(1,ib)+zkod(2,ia)*zko(2,ib)+zkod(3,ia)*zko(3,ib))
zr1adb(ia,ib,1,2)=
. -alm*zkod(1,ia)*zd(2,1)*zko(2,ib)/(zd(1,3)*zd(3,2))
. -bem*zkod(1,ia)*zd(3,1)*zko(3,ib)/(zd(1,3)*zd(3,2))
. -gam*zkod(2,ia)*zud(2,3)*zko(3,ib)/(zud(1,3)*zd(3,2))
. -dem*zud(2,3)/(zd(2,3)*zud(1,2))
. *(zkod(1,ia)*zko(1,ib)+zkod(2,ia)*zko(2,ib)+zkod(3,ia)*zko(3,ib))
zl1adb(ib,ia,1,1)=conjg(zr1adb(ia,ib,1,1))
zl1adb(ib,ia,1,2)=conjg(zr1adb(ia,ib,1,2))
17 continue
endif
endif
c
if (n.eq.2) then
factor=4D0
ihel=4
iperm=2
call f2sadb(3,4,1,1,2,3,4)
call f2sadb(4,3,2,1,3,2,4)
do 8 ih=1,ihel
do 8 ip=1,iperm
do 8 ia=1,2
do 8 ib=1,2
zrsadb(ia,ib,ip,ih)=zsadb(ia,ib,ip,ih)
zlsadb(ib,ia,ip,ih)=conjg(zsadb(ia,ib,ip,ih))
8 continue
endif
c
do 10 ih=1,ihel
do 10 ip=1,iperm
zrr(ip,ih)=zspv(zrsadb(1,1,ip,ih),zrcur(1,1))
zrl(ip,ih)=zspv(zlsadb(1,1,ip,ih),zrcur(1,1))
zlr(ip,ih)=zspv(zrsadb(1,1,ip,ih),zlcur(1,1))
zll(ip,ih)=zspv(zlsadb(1,1,ip,ih),zlcur(1,1))
c
c non-tree level loop amplitudes contracted into lepton current
c
if(nloop.eq.1.and.n.eq.1)then
z1rr(ip,ih)=zspv(zr1adb(1,1,ip,ih),zrcur(1,1))
z1rl(ip,ih)=zspv(zl1adb(1,1,ip,ih),zrcur(1,1))
z1lr(ip,ih)=zspv(zr1adb(1,1,ip,ih),zlcur(1,1))
z1ll(ip,ih)=zspv(zl1adb(1,1,ip,ih),zlcur(1,1))
endif
10 continue
c
do 15 i=1,3
do 15 j=1,2
rl(i,j)=0D0
rr(i,j)=0D0
15 continue
c
if(nloop.eq.0)then
tloop=1D0
elseif(nloop.eq.1)then
c
c one-loop contribution proportional to tree level
c
if(n.eq.0)then
y12=rin(1,2)/rin(6,7)
c$$$ dl12=log(y12/ymin)
c$$$ e0=-dl12**2+3D0*dl12/2D0+pi**2/6D0-1D0/2D0
c$$$ tloop=1D0+4D0*as/3D0/pi*e0
C---THIS MODIFICATION MADE BY MIKE BY ANALOGY WITH THE ONE BELOW
e0=pi**2/2-4
tloop=0D0+4D0*as/3D0/pi*e0
elseif(n.eq.1)then
y12=rin(1,2)/rin(6,7)
y13=rin(1,3)/rin(6,7)
y23=rin(2,3)/rin(6,7)
c$$$ dl12=log(y12/ymin)
c$$$ dl13=log(y13/ymin)
c$$$ dl23=log(y23/ymin)
c$$$ dlm2=log(renscl**2/rmz**2/ymin)
c$$$ e0=29D0/9D0+pi**2/3D0+3D0/4D0*dl13+3D0/4D0*dl23
c$$$ . -dl13**2-dl23**2
c$$$ e2=-dl12**2+3D0*dl12/2D0+pi**2/6D0-1D0/2D0
c$$$ e1=5D0/9D0
C---THIS MODIFICATION SENT BY NIGEL GLOVER TO GIVE ERT FINITE TERMS
dly12=log(y12)
dly13=log(y13)
dly23=log(y23)
dlm2=0D0
C---PI**2 COEFFICIENT CHANGED BY MIKE
e0=pi**2-4D0-dly13**2/2D0-dly23**2/2D0
e2=pi**2/2-4D0-dly12**2/2D0
e1=0D0
tloop=0D0+as*3D0/2D0/pi*(e0-e2/9D0-nf*e1/3D0)+as*b0*dlm2
if(iorder.eq.1)tloop=0D0+as*3D0/2D0/pi*e0+as*b0*dlm2
if(iorder.eq.2)tloop=0D0-as*3D0/2D0/pi*e2/9D0+as*b0*dlm2
if(iorder.eq.3)tloop=0D0-as*3D0/2D0/pi*nf*e1/3D0+as*b0*dlm2
elseif(n.eq.2)then
tloop=1D0
endif
endif
fac=factor*tloop
zprgg=zprg*conjg(zprg)
zprzg=zprz*conjg(zprg)
zprzz=zprz*conjg(zprz)
do 20 i=1,ihel
do 20 j1=1,iperm
do 20 j2=1,iperm
zrrrr=zrr(j1,i)*conjg(zrr(j2,i))
zrlrl=zrl(j1,i)*conjg(zrl(j2,i))
zlrlr=zlr(j1,i)*conjg(zlr(j2,i))
zllll=zll(j1,i)*conjg(zll(j2,i))
*
* left-handed contributions
*
rl(1,1)=rl(1,1)+fac*col(j1,j2,n)*zprgg*(
. +(zlrlr*cgur*cgur+zllll*cgul*cgul)*cgll*cgll )
zz=fac*col(j1,j2,n)*zprzg*(
. +(zlrlr*czur*cgur+zllll*czul*cgul)*czll*cgll )
rl(2,1)=rl(2,1)+2D0*real(zz)
rl(3,1)=rl(3,1)+fac*col(j1,j2,n)*zprzz*(
. +(zlrlr*czur*czur+zllll*czul*czul)*czll*czll )
rl(1,2)=rl(1,2)+fac*col(j1,j2,n)*zprgg*(
. +(zlrlr*cgdr*cgdr+zllll*cgdl*cgdl)*cgll*cgll )
zz=fac*col(j1,j2,n)*zprzg*(
. +(zlrlr*czdr*cgdr+zllll*czdl*cgdl)*czll*cgll )
rl(2,2)=rl(2,2)+2D0*real(zz)
rl(3,2)=rl(3,2)+fac*col(j1,j2,n)*zprzz*(
. +(zlrlr*czdr*czdr+zllll*czdl*czdl)*czll*czll )
*
* right-handed contributions
*
rr(1,1)=rr(1,1)+fac*col(j1,j2,n)*zprgg*(
. +(zrrrr*cgur*cgur+zrlrl*cgul*cgul)*cglr*cglr )
zz=fac*col(j1,j2,n)*zprzg*(
. +(zrrrr*czur*cgur+zrlrl*czul*cgul)*czlr*cglr )
rr(2,1)=rr(2,1)+2D0*real(zz)
rr(3,1)=rr(3,1)+fac*col(j1,j2,n)*zprzz*(
. +(zrrrr*czur*czur+zrlrl*czul*czul)*czlr*czlr )
rr(1,2)=rr(1,2)+fac*col(j1,j2,n)*zprgg*(
. +(zrrrr*cgdr*cgdr+zrlrl*cgdl*cgdl)*cglr*cglr )
zz=fac*col(j1,j2,n)*zprzg*(
. +(zrrrr*czdr*cgdr+zrlrl*czdl*cgdl)*czlr*cglr )
rr(2,2)=rr(2,2)+2D0*real(zz)
rr(3,2)=rr(3,2)+fac*col(j1,j2,n)*zprzz*(
. +(zrrrr*czdr*czdr+zrlrl*czdl*czdl)*czlr*czlr )
20 continue
*
* Equivalent expressions for the gluon interference term: (+-)+(-+)
*
if (n.eq.1.and.nloop.eq.0) then
j1=1
j2=1
zrrrr=zrr(j1,1)*conjg(zrr(j2,2))
zrlrl=zrl(j1,1)*conjg(zrl(j2,2))
zlrlr=zlr(j1,1)*conjg(zlr(j2,2))
zllll=zll(j1,1)*conjg(zll(j2,2))
*
* left-handed contributions
*
zhl(1,1)=fac*col(j1,j2,n)*zprgg*(
. +(zlrlr*cgur*cgur+zllll*cgul*cgul)*cgll*cgll )
zz=fac*col(j1,j2,n)*zprzg*(
. +(zlrlr*czur*cgur+zllll*czul*cgul)*czll*cgll )
zhl(2,1)=2D0*real(zz)
zhl(3,1)=fac*col(j1,j2,n)*zprzz*(
. +(zlrlr*czur*czur+zllll*czul*czul)*czll*czll )
zhl(1,2)=fac*col(j1,j2,n)*zprgg*(
. +(zlrlr*cgdr*cgdr+zllll*cgdl*cgdl)*cgll*cgll )
zz=fac*col(j1,j2,n)*zprzg*(
. +(zlrlr*czdr*cgdr+zllll*czdl*cgdl)*czll*cgll )
zhl(2,2)=2D0*real(zz)
zhl(3,2)=fac*col(j1,j2,n)*zprzz*(
. +(zlrlr*czdr*czdr+zllll*czdl*czdl)*czll*czll )
*
* right-handed contributions
*
zhr(1,1)=fac*col(j1,j2,n)*zprgg*(
. +(zrrrr*cgur*cgur+zrlrl*cgul*cgul)*cglr*cglr )
zz=fac*col(j1,j2,n)*zprzg*(
. +(zrrrr*czur*cgur+zrlrl*czul*cgul)*czlr*cglr )
zhr(2,1)=2D0*real(zz)
zhr(3,1)=fac*col(j1,j2,n)*zprzz*(
. +(zrrrr*czur*czur+zrlrl*czul*czul)*czlr*czlr )
zhr(1,2)=fac*col(j1,j2,n)*zprgg*(
. +(zrrrr*cgdr*cgdr+zrlrl*cgdl*cgdl)*cglr*cglr )
zz=fac*col(j1,j2,n)*zprzg*(
. +(zrrrr*czdr*cgdr+zrlrl*czdl*cgdl)*czlr*cglr )
zhr(2,2)=2D0*real(zz)
zhr(3,2)=fac*col(j1,j2,n)*zprzz*(
. +(zrrrr*czdr*czdr+zrlrl*czdl*czdl)*czlr*czlr )
endif
c
c higher order contributions
c
if(nloop.eq.1)then
c
c interference between non-tree level structures and tree level
c
if(n.eq.1)then
fac=factor*3D0*as/4D0/pi
do 30 i=1,ihel
do 30 j1=1,iperm
do 30 j2=1,iperm
z1rrrr=z1rr(j1,i)*conjg(zrr(j2,i))
z1rlrl=z1rl(j1,i)*conjg(zrl(j2,i))
z1lrlr=z1lr(j1,i)*conjg(zlr(j2,i))
z1llll=z1ll(j1,i)*conjg(zll(j2,i))
*
* left-handed contributions
*
zz=fac*col(j1,j2,n)*zprgg*(
. +(z1lrlr*cgur*cgur+z1llll*cgul*cgul)*cgll*cgll )
rl(1,1)=rl(1,1)+2D0*real(zz)
zz=fac*col(j1,j2,n)*zprzg*(
. +(z1lrlr*czur*cgur+z1llll*czul*cgul)*czll*cgll )
rl(2,1)=rl(2,1)+2D0*real(zz)
zz=fac*col(j1,j2,n)*zprzz*(
. +(z1lrlr*czur*czur+z1llll*czul*czul)*czll*czll )
rl(3,1)=rl(3,1)+2D0*real(zz)
zz=fac*col(j1,j2,n)*zprgg*(
. +(z1lrlr*cgdr*cgdr+z1llll*cgdl*cgdl)*cgll*cgll )
rl(1,2)=rl(1,2)+2D0*real(zz)
zz=fac*col(j1,j2,n)*zprzg*(
. +(z1lrlr*czdr*cgdr+z1llll*czdl*cgdl)*czll*cgll )
rl(2,2)=rl(2,2)+2D0*real(zz)
zz=fac*col(j1,j2,n)*zprzz*(
. +(z1lrlr*czdr*czdr+z1llll*czdl*czdl)*czll*czll )
rl(3,2)=rl(3,2)+2D0*real(zz)
*
* right-handed contributions
*
zz=fac*col(j1,j2,n)*zprgg*(
. +(z1rrrr*cgur*cgur+z1rlrl*cgul*cgul)*cglr*cglr )
rr(1,1)=rr(1,1)+2D0*real(zz)
zz=fac*col(j1,j2,n)*zprzg*(
. +(z1rrrr*czur*cgur+z1rlrl*czul*cgul)*czlr*cglr )
rr(2,1)=rr(2,1)+2D0*real(zz)
zz=fac*col(j1,j2,n)*zprzz*(
. +(z1rrrr*czur*czur+z1rlrl*czul*czul)*czlr*czlr )
rr(3,1)=rr(3,1)+2D0*real(zz)
zz=fac*col(j1,j2,n)*zprgg*(
. +(z1rrrr*cgdr*cgdr+z1rlrl*cgdl*cgdl)*cglr*cglr )
rr(1,2)=rr(1,2)+2D0*real(zz)
zz=fac*col(j1,j2,n)*zprzg*(
. +(z1rrrr*czdr*cgdr+z1rlrl*czdl*cgdl)*czlr*cglr )
rr(2,2)=rr(2,2)+2D0*real(zz)
zz=fac*col(j1,j2,n)*zprzz*(
. +(z1rrrr*czdr*czdr+z1rlrl*czdl*czdl)*czlr*czlr )
rr(3,2)=rr(3,2)+2D0*real(zz)
30 continue
endif
endif
c
end
c
c***********************************************************************
c subroutine ert(iq,ip,ik,al,be,ga,de) computes the functions multiplyin
c the different one-loop helicity structures
c***********************************************************************
c call ert(iq,ip,ik,al,be,ga,de)
c iq,ip and ik point to the momenta of the quark, antiquark and gluon
c al, be and ga are the functions multiplying the helicity structures
c***********************************************************************
subroutine ert(iq,ip,ik,al,be,ga,de)
implicit double precision(a-h,o-y)
parameter(pi=3.141592653589793238D0)
common /linpr/ rin(7,7)
common /order/iorder
c
yqp=rin(iq,ip)/rin(6,7)
yqk=rin(iq,ik)/rin(6,7)
ykp=rin(ik,ip)/rin(6,7)
omyqp=1D0-yqp
omyqk=1D0-yqk
omykp=1D0-ykp
dlqp=log(yqp)
dlqk=log(yqk)
dlkp=log(ykp)
dlomqp=log(omyqp)
dlomqk=log(omyqk)
dlomkp=log(omykp)
spqp=rsp(yqp)
spqk=rsp(yqk)
spkp=rsp(ykp)
rqpkp=dlqp*dlkp-dlqp*dlomqp-dlkp*dlomkp+pi**2/6D0-spqp-spkp
rqpqk=dlqp*dlqk-dlqp*dlomqp-dlqk*dlomqk+pi**2/6D0-spqp-spqk
rqkkp=dlqk*dlkp-dlqk*dlomqk-dlkp*dlomkp+pi**2/6D0-spqk-spkp
c
al0=-rqkkp
. -ykp*(4D0-3D0*ykp)/2D0/omykp**2*dlkp
. -ykp/2D0/omykp
be0=-rqkkp
. +(4D0-3D0*ykp)/2D0/omykp*dlkp
. +1D0
ga0=+ykp/2D0/omykp**2*dlkp
. +ykp/2D0/omykp
de0=+(yqp*ykp/2D0/omykp**2+yqp/omykp)*dlkp
. +yqp/2D0/omykp
c
al2=-rqpqk
. -omyqp**2/yqk**2*rqpkp
. -ykp/yqk*dlqp
. -(ykp*(4D0-3D0*ykp)/2D0/omykp**2+ykp**2/yqk/omykp)*dlkp
. -ykp/2D0/omykp
be2=-rqpqk
. +(yqp*omyqp/yqk**2+1D0/yqk)*rqpkp
. +(yqk/omyqp**2+omykp/yqk)*dlqp
. +((4D0-3D0*ykp)/2D0/omykp+ykp/yqk)*dlkp
. +yqk/omyqp
ga2=+ykp/yqk**2*rqpkp
. -(yqk/omyqp**2-1D0/yqk)*dlqp
. +(ykp/2D0/omykp**2+ykp/yqk/omykp)*dlkp
. +ykp/omyqp+ykp/2D0/omykp
de2=+yqp*omyqp/yqk**2*rqpkp
. +yqp/yqk*dlqp
. +(yqp*ykp/2D0/omykp**2+yqp*omyqp/yqk/omykp)*dlkp
. +yqp/2D0/omykp
c
C---THESE LINES REMOVED BY MIKE FOR ERT DEFINITION OF COLLINEAR PIECES
c$$$ al0=al0-3D0/4D0*dlqk-3D0/4D0*dlkp
c$$$ be0=be0-3D0/4D0*dlqk-3D0/4D0*dlkp
c$$$ al2=al2-3D0/2D0*dlqp
c$$$ be2=be2-3D0/2D0*dlqp
c
if(iorder.eq.0)then
al=al0-al2/9D0
be=be0-be2/9D0
ga=ga0-ga2/9D0
de=de0-de2/9D0
elseif(iorder.eq.1)then
al=al0
be=be0
ga=ga0
de=de0
elseif(iorder.eq.2)then
al=-al2/9D0
be=-be2/9D0
ga=-ga2/9D0
de=-de2/9D0
endif
c check : t0 and t2 should be zero
c t0=-al0+be0-ga0-2D0/yqp*de0
c t2=-al2+be2-ga2-2D0/yqp*de2
c write(*,*)t0,t2
end
c**********************************************************************
c subroutine f2sadb(i1,i2,index,j1,j2,j3,j4) calculates the four
c helicity amplitudes for the permutation of the gluons (i1,i2).
c the quark(q) having + helicity and the anti-quark(p) - helictity.
c the calculation is organized as follows:
c after calculating the various propagators, all the spinor
c currents from the form: ( propagator contracted with a spinor)
c are composed. the currents containing the q are dotted. those with
c the qb are undotted.
c example: zD12m2 is the spinor (q+g(i1)+g(i2))adb * g(i2)b
c after initializing various constants belonging to a certain helicity
c combination, e.g. zppx belongs to the combination where both
c gluons have helicity +, the currents zsadb are calculated.
c**********************************************************************
c calling conventions:
c i1,i2 = permutation of the gluons. because they are used
c as indices we added two.
c this way we have (i1,i2)= (3,4) or (4,3)
c index = permutation counter
c j1,j2,j3,j4 = indices to get the helicity currents on the
c right spot in the data structures sadb.
c also needed are commons /spinor/ and /dotpr/
c**********************************************************************
c output conventions:
c put all the helicity combinations of a certain
c permutation (i1,i2) in the data-structure zsadb(2,2,2,4)
c**********************************************************************
subroutine f2sadb(i1,i2,index,j1,j2,j3,j4)
implicit double precision(a-h,o-y)
implicit complex*16(z)
common /esadb/ zsadb(2,2,2,4)
common /dotpr/ zud(7,7),zd(7,7),zko(7,2),zkod(7,2),negaen
common /linpr/ rin(7,7)
dimension zD12m1(2),zD12m2(2),zD12mp(2),
. z12pm1(2),z12pm2(2),z12pmq(2)
c
pro12=2D0*rin(i1,i2)
proD12=pro12+2D0*(rin(1,i1)+rin(1,i2))
pro12p=pro12+2D0*(rin(2,i1)+rin(2,i2))
c
do 10 i=1,2
zD12m1(i)=zkod(1,i)*zud(1,i1)+zkod(i2,i)*zud(i2,i1)
zD12m2(i)=zkod(1,i)*zud(1,i2)+zkod(i1,i)*zud(i1,i2)
zD12mp(i)=zkod(1,i)*zud(1,2)+zkod(i1,i)*zud(i1,2)
. +zkod(i2,i)*zud(i2,2)
z12pm1(i)=zko(2,i)*zd(2,i1)+zko(i2,i)*zd(i2,i1)
z12pm2(i)=zko(2,i)*zd(2,i2)+zko(i1,i)*zd(i1,i2)
z12pmq(i)=zko(2,i)*zd(2,1)+zko(i1,i)*zd(i1,1)+zko(i2,i)*zd(i2,1)
10 continue
c
zppa=-1D0/(zud(1,i1)*zud(i1,i2)*zud(i2,2))
zpma=zd(1,i1)*zud(1,i2)/(pro12*proD12*zud(1,i1))
zpmb=zd(2,i1)*zud(2,i2)/(pro12*pro12p*zd(2,i2))
zpmc=1D0/(pro12*zud(1,i1)*zd(i2,2))
zmpa=zud(2,i1)**2/(pro12*pro12p*zud(2,i2))
zmpb=zd(1,i2)**2/(pro12*proD12*zd(1,i1))
zmpc=-zd(1,i2)*zud(2,i1)/(pro12*zd(1,i1)*zud(2,i2))
zmma=1D0/(zd(1,i1)*zd(i1,i2)*zd(i2,2))
c
do 20 ia=1,2
do 20 ib=1,2
zsadb(ia,ib,index,j1)=-zppa*zD12mp(ia)*zko(2,ib)
zsadb(ia,ib,index,j2)=-zpma*zD12m2(ia)*zko(2,ib)
. -zpmb*zkod(1,ia)*z12pm1(ib)
. -zpmc*zD12m2(ia)*z12pm1(ib)
zsadb(ia,ib,index,j3)=-zmpa*zkod(1,ia)*z12pm2(ib)
. -zmpb*zD12m1(ia)*zko(2,ib)
. -zmpc*zkod(1,ia)*zko(2,ib)
zsadb(ia,ib,index,j4)=-zmma*zkod(1,ia)*z12pmq(ib)
20 continue
c
end
c
c**********************************************************************
c matrix element for: e+ e- --> g,z --> q qb q qb
c**********************************************************************
c information: the particles in plab are ordered as follows:
c 1,2 : incoming e+ and e-
c 3,5 : outgoing quarks
c 4,6 : outgoing anti-quarks
c sw2: square of sin(weak angle)
c rmz: mass of z
c rgz: width of z
c
c output: the matrix elements for the subprocesses returned in
c rl(3,5) for left handed contribution
c rr(3,5) for right handed contribution
c first index 1 = gg
c 2 = gz
c 3 = zz
c second index 1 = same quarks up-type
c 2 = same quarks down-type
c 3 = different quarks up-type
c 4 = different quarks down-type
c 5 = different quarks up - down pairs
c**********************************************************************
c not included: strong coupling constants!
c statistics, spin averages.
c**********************************************************************
c calling procedure for subroutines:
c 1 : anti-particle
c 2 : particle
c 3,5: labels of quarks in plab array
c 4,6: labels of anti-quarks in plab array
c particles 1 and 2 are always flipped: we consider all particle
c to be outgoing.
c**********************************************************************
c most of the formulae in this program can be found in:
c exact expressions for processes involving a vector boson
c and up to five partons. (berends, giele, kuijf)
c**********************************************************************
C---MODIFIED BY MIKE TO ENABLE SIMPLE SUMMING OVER PERMS
C QUARK 1 HAS BEEN REPLACED BY VARIABLE I1 EVERYWHERE, ETC
subroutine eeq4(rl,rr,rmz,rgz,I1,I2,I3,I4)
implicit double precision(a-h,o-y)
implicit complex*16(z)
common /mom/ plab(4,10)
common /kinema/ p(4,7)
common /zqqqq/ zr(4,6),zl(4,6)
common /curent/ zrcur(2,2),zlcur(2,2)
dimension za(2,2),zb(2,2)
dimension rl(3,5),rr(3,5)
c
c fill h functions
c the problem of an odd number of quark-particles with negative
c energy is handled within the h-functions.
c handle ppmm and mmpp
call hpmmp(I1,I4,I3,I2,-1D0,za(1,1),zb(1,1))
zr(1,1)=zspv(zrcur(1,1),za(1,1))
zl(1,1)=zspv(zlcur(1,1),za(1,1))
zr(1,4)=zspv(zrcur(1,1),zb(1,1))
zl(1,4)=zspv(zlcur(1,1),zb(1,1))
call hpmmp(I3,I2,I1,I4,-1D0,za(1,1),zb(1,1))
zr(2,4)=zspv(zrcur(1,1),za(1,1))
zl(2,4)=zspv(zlcur(1,1),za(1,1))
zr(2,1)=zspv(zrcur(1,1),zb(1,1))
zl(2,1)=zspv(zlcur(1,1),zb(1,1))
c
c handle pmmp and mppm
call hpmmp(I1,I2,I3,I4,1D0,za(1,1),zb(1,1))
zr(1,2)=zspv(zrcur(1,1),za(1,1))
zl(1,2)=zspv(zlcur(1,1),za(1,1))
zr(1,3)=zspv(zrcur(1,1),zb(1,1))
zl(1,3)=zspv(zlcur(1,1),zb(1,1))
call hpmmp(I3,I4,I1,I2,1D0,za(1,1),zb(1,1))
zr(2,3)=zspv(zrcur(1,1),za(1,1))
zl(2,3)=zspv(zlcur(1,1),za(1,1))
zr(2,2)=zspv(zrcur(1,1),zb(1,1))
zl(2,2)=zspv(zlcur(1,1),zb(1,1))
c
c handle pmpm and mpmp
call hpmpm(I1,I2,I3,I4,1D0,za(1,1),zb(1,1))
zr(1,5)=zspv(zrcur(1,1),za(1,1))
zl(1,5)=zspv(zlcur(1,1),za(1,1))
zr(1,6)=zspv(zrcur(1,1),zb(1,1))
zl(1,6)=zspv(zlcur(1,1),zb(1,1))
call hpmpm(I1,I4,I3,I2,-1D0,za(1,1),zb(1,1))
zr(2,5)=zspv(zrcur(1,1),za(1,1))
zl(2,5)=zspv(zlcur(1,1),za(1,1))
zr(2,6)=zspv(zrcur(1,1),zb(1,1))
zl(2,6)=zspv(zlcur(1,1),zb(1,1))
call hpmpm(I3,I4,I1,I2,1D0,za(1,1),zb(1,1))
zr(3,5)=zspv(zrcur(1,1),za(1,1))
zl(3,5)=zspv(zlcur(1,1),za(1,1))
zr(3,6)=zspv(zrcur(1,1),zb(1,1))
zl(3,6)=zspv(zlcur(1,1),zb(1,1))
call hpmpm(I3,I2,I1,I4,-1D0,za(1,1),zb(1,1))
zr(4,5)=zspv(zrcur(1,1),za(1,1))
zl(4,5)=zspv(zlcur(1,1),za(1,1))
zr(4,6)=zspv(zrcur(1,1),zb(1,1))
zl(4,6)=zspv(zlcur(1,1),zb(1,1))
c
c insert different couplings to obtain subprocesses
c
call squar(1,1,rmz,rgz,rl(1,1),rr(1,1))
call squar(2,2,rmz,rgz,rl(1,2),rr(1,2))
call squar(1,3,rmz,rgz,rl(1,3),rr(1,3))
call squar(2,4,rmz,rgz,rl(1,4),rr(1,4))
call squar(1,2,rmz,rgz,rl(1,5),rr(1,5))
c
end
c
c**********************************************************************
c function squar calculates the matrix element squared of the
c e+ e- --> g,z --> q + qb + q + qb
c**********************************************************************
c desciption of the common zqqqq
c the first is the index for the squared matrix
c the second index are the different subamplitudes (6)
c the first and the second are indices in the squared matrix
c index 3=1 --> ++--, =2 --> +--+, =3 --> -++-, =4 --> --++
c index 3=5 --> +-+-, =6 --> -+-+
c**********************************************************************
c output : rl(3) 1: gg 2: gz 3: zz
c rr(3) 1: gg 2: gz 3: zz
c**********************************************************************
subroutine squar(ityp1,ityp2,rmz,rgz,rl,rr)
implicit double precision (a-h,o-y)
implicit complex*16(z)
parameter(c1=8D0,c2=-8D0/3D0)
common /zqqqq/ zr(4,6),zl(4,6)
dimension s2g(4,2),s2z(4,2),s4g(2,4),s4z(2,4)
dimension col4(4,4),col2(2,2),rl(3),rr(3)
common /zcup/czur,czul,czdr,czdl,czlr,czll,cznr,cznl
common /gcup/cgur,cgul,cgdr,cgdl,cglr,cgll,cgnr,cgnl
data col4/c1,c2,c1,c2,c2,c1,c2,c1,c1,c2,c1,c2,c2,c1,c2,c1/
data col2/c1,c1,c1,c1/
C---THESE LINES REMOVED BY MIKE TO FACILITATE SUMMATION OVER PERMS
C (THEY WERE SUPERFLUOUS ANYWAY, SINCE THE ARRAYS WERE EMPTY ALREADY)
c$$$c
c$$$c init answer
c$$$ rl(1)=0D0
c$$$ rl(2)=0D0
c$$$ rl(3)=0D0
c$$$ rr(1)=0D0
c$$$ rr(2)=0D0
c$$$ rr(3)=0D0
c
c couplings and all that (like energy dependent width for z propagator).
s=2D0*rinpro(6,7)
zprg=(0D0,-1D0)/s
zprz=(0D0,-1D0)/(s-rmz**2+(0D0,1D0)*s*rgz/rmz)
if(ityp1.eq.1)then
cg1r=cgur
cg1l=cgul
cz1r=czur
cz1l=czul
elseif(ityp1.eq.2)then
cg1r=cgdr
cg1l=cgdl
cz1r=czdr
cz1l=czdl
endif
if(ityp2.eq.1.or.ityp2.eq.3)then
cg2r=cgur
cg2l=cgul
cz2r=czur
cz2l=czul
elseif(ityp2.eq.2.or.ityp2.eq.4)then
cg2r=cgdr
cg2l=cgdl
cz2r=czdr
cz2l=czdl
endif
c
if(ityp1.eq.ityp2)then
delta=1D0
else
delta=0D0
endif
c
c s2(1,.) is ppmm
s2g(1,1)=delta*cg1r
s2z(1,1)=delta*cz1r
s2g(1,2)=delta*cg1l
s2z(1,2)=delta*cz1l
c s2(2,.) is pmmp
s2g(2,1)=cg1r
s2z(2,1)=cz1r
s2g(2,2)=cg2l
s2z(2,2)=cz2l
c s2(3,.) is mppm
s2g(3,1)=cg1l
s2z(3,1)=cz1l
s2g(3,2)=cg2r
s2z(3,2)=cz2r
c s2(4,.) is mmpp
s2g(4,1)=delta*cg1l
s2z(4,1)=delta*cz1l
s2g(4,2)=delta*cg1r
s2z(4,2)=delta*cz1r
c
zprgg=zprg*conjg(zprg)
zprzg=zprz*conjg(zprg)
zprzz=zprz*conjg(zprz)
do 10 i=1,4
ij=i
do 11 ix=1,2
do 12 iy=1,2
zrr=zr(ix,i)*conjg(zr(iy,i))
zll=zl(ix,i)*conjg(zl(iy,i))
c
c left-handed contributions
c
rl(1)=rl(1)+col2(ix,iy)*s2g(ij,ix)*s2g(ij,iy)*
. zprgg*cgll*cgll*zll
zz=col2(ix,iy)*s2g(ij,ix)*s2z(ij,iy)*
. zprzg*czll*cgll*zll
rl(2)=rl(2)+2D0*real(zz)
rl(3)=rl(3)+col2(ix,iy)*s2z(ij,ix)*s2z(ij,iy)*
. zprzz*czll*czll*zll
c
c right-handed contributions
c
rr(1)=rr(1)+col2(ix,iy)*s2g(ij,ix)*s2g(ij,iy)*
. zprgg*cglr*cglr*zrr
zz=col2(ix,iy)*s2g(ij,ix)*s2z(ij,iy)*
. zprzg*czlr*cglr*zrr
rr(2)=rr(2)+2D0*real(zz)
rr(3)=rr(3)+col2(ix,iy)*s2z(ij,ix)*s2z(ij,iy)*
. zprzz*czlr*czlr*zrr
12 continue
11 continue
10 continue
c
c s4(1,.) is pmpm
s4g(1,1)=cg1r
s4z(1,1)=cz1r
s4g(1,2)=delta*cg1r
s4z(1,2)=delta*cz1r
s4g(1,3)=cg2r
s4z(1,3)=cz2r
s4g(1,4)=delta*cg1r
s4z(1,4)=delta*cz1r
c s4(2,.) is mpmp
s4g(2,1)=cg1l
s4z(2,1)=cz1l
s4g(2,2)=delta*cg1l
s4z(2,2)=delta*cz1l
s4g(2,3)=cg2l
s4z(2,3)=cz2l
s4g(2,4)=delta*cg1l
s4z(2,4)=delta*cz1l
c
do 20 i=5,6
ij=(i-4)
do 21 ix=1,4
do 22 iy=1,4
zrr=zr(ix,i)*conjg(zr(iy,i))
zll=zl(ix,i)*conjg(zl(iy,i))
c
c left-handed contributions
c
rl(1)=rl(1)+col4(ix,iy)*s4g(ij,ix)*s4g(ij,iy)*
. zprgg*cgll*cgll*zll
zz=col4(ix,iy)*s4g(ij,ix)*s4z(ij,iy)*
. zprzg*czll*cgll*zll
rl(2)=rl(2)+2D0*real(zz)
rl(3)=rl(3)+col4(ix,iy)*s4z(ij,ix)*s4z(ij,iy)*
. zprzz*czll*czll*zll
c
c right-handed contributions
c
rr(1)=rr(1)+col4(ix,iy)*s4g(ij,ix)*s4g(ij,iy)*
. zprgg*cglr*cglr*zrr
zz=col4(ix,iy)*s4g(ij,ix)*s4z(ij,iy)*
. zprzg*czlr*cglr*zrr
rr(2)=rr(2)+2D0*real(zz)
rr(3)=rr(3)+col4(ix,iy)*s4z(ij,ix)*s4z(ij,iy)*
. zprzz*czlr*czlr*zrr
22 continue
21 continue
20 continue
c
end
c the problem of an odd number of quark-particles with negative
c energy is handled within the h-functions.
c**********************************************************************
c subroutine hpmpm calculates the h-function when the helicities of
c the quarks are +-+-.
c call the h-functions with:
c argument 1-4 : quark permutation
c argument 5 is the sign of the h-function (exchange of two
c identical fermions)
c argument 6 is where to put it in zessen
c argument 7 is where to put its complex conjugate.
c z1 and z2 are the 2*2 complex matrices which are the h-vectors
c in spinor language. z2 is always the c.c. of z1. when there
c are an odd number of quarks with negative energy we have to add
c an extra minus sign when complex conjugating. this sign is
c in the common /dotpr/ negaen and is calculated before through
c the call setspn(4,4) in squar
c**********************************************************************
subroutine hpmpm(i1,i2,i3,i4,sign,z1,z2)
implicit double precision(a-h,o-y)
implicit complex*16(z)
common /dotpr/ zud(7,7),zd(7,7),zko(7,2),zkod(7,2),negaen
common /linpr/ rin(7,7)
dimension z1(2,2),z2(2,2)
c
pro34=2D0*rin(i3,i4)
pro134=pro34+2D0*(rin(i1,i3)+rin(i1,i4))
pro234=pro34+2D0*(rin(i2,i3)+rin(i2,i4))
c
zf1=-sign*zd(i1,i3)/(pro34*pro134)
zf2=-sign*zud(i2,i4)/(pro34*pro234)
do 10 ix=1,2
do 10 iy=1,2
z1(ix,iy)=+zf1*zko(i2,iy)*(zud(i1,i4)*zkod(i1,ix)+
. zud(i3,i4)*zkod(i3,ix))
. -zf2*zkod(i1,ix)*(zd(i2,i3)*zko(i2,iy)+
. zd(i4,i3)*zko(i4,iy))
10 continue
call congat(z1,z2)
end
c
c**********************************************************************
c subroutine hpmmp calculates the h-function when the helicities of
c the quarks are +--+. see also subroutine hpmpm
c**********************************************************************
subroutine hpmmp(i1,i2,i3,i4,sign,z1,z2)
implicit double precision(a-h,o-y)
implicit complex*16(z)
common /dotpr/ zud(7,7),zd(7,7),zko(7,2),zkod(7,2),negaen
common /linpr/ rin(7,7)
dimension z1(2,2),z2(2,2)
c
pro34=2D0*rin(i3,i4)
pro134=pro34+2D0*(rin(i1,i3)+rin(i1,i4))
pro234=pro34+2D0*(rin(i2,i3)+rin(i2,i4))
c
zf1=-sign*zd(i1,i4)/(pro34*pro134)
zf2=-sign*zud(i2,i3)/(pro34*pro234)
do 10 ix=1,2
do 10 iy=1,2
z1(ix,iy)=+zf1*zko(i2,iy)*(zud(i1,i3)*zkod(i1,ix)+
. zud(i4,i3)*zkod(i4,ix))
. -zf2*zkod(i1,ix)*(zd(i2,i4)*zko(i2,iy)+
. zd(i3,i4)*zko(i3,iy))
10 continue
call congat(z1,z2)
end
c
c**********************************************************************
c subroutine congat(z1,z2) takes the complex conjugate
c spinor-tensor of z1 into z2. use negaen to correct for
c an odd number of quarks with negative energy.
c**********************************************************************
subroutine congat(z1,z2)
implicit double precision(a-h,o-y)
implicit complex*16(z)
common /dotpr/ zud(7,7),zd(7,7),zko(7,2),zkod(7,2),negaen
dimension z1(2,2),z2(2,2)
c
z2(1,1)=negaen*conjg(z1(1,1))
z2(2,1)=negaen*conjg(z1(1,2))
z2(1,2)=negaen*conjg(z1(2,1))
z2(2,2)=negaen*conjg(z1(2,2))
end
c
c**********************************************************************
c subroutine setspn(n) determines the co-variant weyl-vd waerden
c spinors and all the possible spinor-inproducts.
c special treatment for particles 6 and 7 (leptons)
c particles with negative energy have an artificial minus
c sign in their dotted spinors.
c**********************************************************************
c calling conventions:
c n = number of of vectors (n must be <= 7 )
c common /kinema/ p = array of covariant vectors (-,-,-,+) metric
c note: none of the vectors should be parallel to the y-axis.
c**********************************************************************
c output conventions:
c common /dotpr/zud(7,7),zd(7,7),zko(7,2),zkod(7,2),negaen
c input parameters remain unchanged.
c with:
c zud(i,j) = undotted spinor inproduct
c zd(i,j) = dotted spinor inproduct
c zko(i,1:2) = undotted co-variant spinors
c zkod(i,1:2) = dotted co-variant spinors
c negaen = number of quarks with negative
c energy. needed when complex-conjugating.
c negaen=1,-1 when that number is even,odd
c**********************************************************************
subroutine setspn(n)
implicit double precision(a-h,o-y)
implicit complex*16(z)
common /kinema/ p(4,7)
common /dotpr/ zud(7,7),zd(7,7),zko(7,2),zkod(7,2),negaen
common /linpr/ rin(7,7)
c
do 10 i=1,7
if((i.le.n).or.(i.ge.6))then
zko(i,1)=(p(1,i)-(0D0,1D0)*p(3,i))
. /sqrt(dcmplx(p(4,i)-p(2,i)))
zko(i,2)=sqrt(dcmplx(p(4,i)-p(2,i)))
zkod(i,1)=conjg(zko(i,1))
zkod(i,2)=conjg(zko(i,2))
if (p(4,i).lt.0D0) then
zkod(i,1)=-zkod(i,1)
zkod(i,2)=-zkod(i,2)
endif
endif
10 continue
c
do 20 i=1,n-1
do 20 j=i,n
zud(i,j)=-zko(i,1)*zko(j,2)+zko(i,2)*zko(j,1)
zud(j,i)=-zud(i,j)
zd(i,j)=-zkod(i,1)*zkod(j,2)+zkod(i,2)*zkod(j,1)
zd(j,i)=-zd(i,j)
20 continue
c
do 30 i=1,n-1
do 30 j=i,n
rin(i,j)=rinpro(i,j)
rin(j,i)=rin(i,j)
30 continue
rin(1,6)=rinpro(1,6)
rin(1,7)=rinpro(1,7)
rin(2,6)=rinpro(2,6)
rin(2,7)=rinpro(2,7)
rin(6,7)=rinpro(6,7)
rin(7,6)=rin(6,7)
end
c
c**********************************************************************
c function rinpro(i,j) determines the minkowski inproduct.
c the parameters i and j refer to the momentum array /kinema/ p.
c both vectors are contra-variant.
c**********************************************************************
function rinpro(i,j)
implicit double precision(a-h,o-y)
common /kinema/ p(4,7)
c
rinpro=p(4,i)*p(4,j)-p(1,i)*p(1,j)-p(2,i)*p(2,j)-p(3,i)*p(3,j)
end
c
c**********************************************************************
c
c two loop strong coupling constant at scale rq
c
function alfas(mu,lam,nloops)
c alfas in terms of lambda of four flavors for one or two loops.
c matching acheived using renorm group eqn. approximately
c above mu=mb,mu=mt
implicit none
integer nloops
double precision mu,lam,mc,mb,mt
double precision b4,b4p,b5,b5p,b6,b6p,one,two
double precision alfas,atinv,abinv,atinv1,abinv1,asinv,xqc,xqb,
$ xqt,xb,xt
parameter(one=1.D0,two=2.D0)
parameter(b4=1.326291192D0,b5=1.220187897D0,b6=1.114084601D0)
parameter(b4p=0.490197225D0,b5p=0.401347248D0,b6p=0.295573466D0)
c b=(33.D0-2.D0*nf)/6.D0/pi
c bp=(153.D0-19.D0*nf)/(2.D0*pi*(33.D0-2.D0*nf))
parameter(mc=1.5D0,mb=5.0D0,mt=140.D0)
if (mu.lt.mc) then
write(6,*) 'unimplemented, mu too low',mu
alfas=0.D0
return
endif
xb=log(mb/lam)
abinv=b4*xb
if (mu.lt.mb) then
xqc=log(mu/lam)
asinv=b4*xqc
alfas=one/asinv
elseif (mu.lt.mt) then
xqb=log(mu/mb)
asinv=abinv+b5*xqb
alfas=one/asinv
else
xqt=log(mu/mt)
xt=log(mt/mb)
atinv=abinv+b5*xt
asinv=atinv+b6*xqt
alfas=one/asinv
endif
if (nloops.eq.1) return
abinv1=abinv/(one-b4p*log(two*xb)/abinv)
if (mu.lt.mb) then
asinv=asinv/(one-b4p*log(two*xqc)/asinv)
alfas=one/asinv
elseif (mu.lt.mt) then
asinv=abinv1+b5*xqb+b5p*log((asinv+b5p)/(abinv+b5p))
alfas=one/asinv
else
atinv1=abinv1+b5*xt+b5p*log((b5p+atinv)/(b5p+abinv))
asinv=atinv1+b6*xqt+b6p*log((b6p+asinv)/(atinv+b6p))
alfas=one/asinv
endif
return
end
C-----------------------------------------------------------------------
C-----------------------------------------------------------------------
C-----------------------------------------------------------------------
C THE ROUTINES FROM HERE ON ARE MORE GENERAL UTILITIES
C - AN APPROXIMATION TO THE DILOGARITHM
C - A RANDOM NUMBER GENERATOR
C-----------------------------------------------------------------------
C-----------------------------------------------------------------------
C-----------------------------------------------------------------------
FUNCTION DILOG(X)
IMPLICIT NONE
c$$$C---RETURN THE DILOGARITHM (MAXIMUM ERROR = 0.0058, MAX FRAC ERROR = 1%)
c$$$ DOUBLE PRECI\ION DILOG,X,PISQO6,OX,XX,L2
c$$$ DATA PISQO6,L2/2*0/
c$$$ IF (PISQO6.EQ.0) PISQO6=(ATAN(1D0)*4)**2/6
c$$$ IF (L2.EQ.0) L2=LOG(2D0)
c$$$ IF (X.LT.-1) THEN
c$$$ XX=1/X
c$$$ ELSE
c$$$ XX=X
c$$$ ENDIF
c$$$ IF (XX.LT.-0.5) THEN
c$$$ OX=1+XX
c$$$ DILOG=-PISQO6/2-L2*LOG(-XX)
c$$$ $ -OX**2/4-5*OX**3/24-OX**4/6-131*OX**5/960
c$$$ ELSEIF (XX.LT.0.5) THEN
c$$$ DILOG=XX+XX**2/4+XX**3/9
c$$$ ELSEIF (XX.LT.1) THEN
c$$$ OX=1-XX
c$$$ DILOG=PISQO6-LOG(OX)*LOG(XX)-OX-OX**2/4-OX**3/9
c$$$ ELSEIF (XX.EQ.1) THEN
c$$$ DILOG=PISQO6
c$$$ ELSE
c$$$ WRITE (*,*) 'DILOG CALLED FOR X=',X
c$$$ DILOG=0
c$$$ ENDIF
c$$$ IF (X.LT.-1) DILOG=-DILOG-PISQO6-LOG(-X)**2/2
double precision dilog,rsp,x
dilog=rsp(x)
END
C-----------------------------------------------------------------------
C-----------------------------------------------------------------------
C-----------------------------------------------------------------------
C-----------------------------------------------------------------------
SUBROUTINE RANGEN(N,R)
IMPLICIT NONE
C---RANDOM NUMBER GENERATOR
C USES METHOD OF l'Ecuyer, (VIA F.JAMES, COMP PHYS COMM 60(1990)329)
C RETURNS A VECTOR OF N RANDOM VALUES
C IF (N.EQ.0) THE FIRST TWO VALUES IN R SET THE SEEDS
C IF (N.LT.0) PRINT THE CURRENT VALUES OF THE SEEDS
DOUBLE PRECISION R(*)
INTEGER N,I,ISEED(2),K,IZ
DATA ISEED/123450,678900/
IF (N.LT.0) WRITE (*,'(I10,A,I10,I11)') -N-1,', ISEED=',ISEED
IF (N.GT.0) THEN
DO I=1,N
K=ISEED(1)/53668
ISEED(1)=40014*(ISEED(1)-K*53668)-K*12211
IF (ISEED(1).LT.0) ISEED(1)=ISEED(1)+2147483563
K=ISEED(2)/52774
ISEED(2)=40692*(ISEED(2)-K*52774)-K*3791
IF (ISEED(2).LT.0) ISEED(2)=ISEED(2)+2147483399
IZ=ISEED(1)-ISEED(2)
IF (IZ.LT.1) IZ=IZ+2147483562
R(I)=DBLE(IZ)*4.656613D-10
ENDDO
ELSEIF (N.EQ.0) THEN
ISEED(1)=NINT(R(1))
ISEED(2)=NINT(R(2))
ENDIF
END
c function zspv(smu,snu) calculates a smu*snu inproduct in
c spinor-tensor language. both smu and snu are co-variant tensors.
c the factor 2 is due to spinor transformation algebra.
c**********************************************************************
function zspv(smu,snu)
complex*16 zspv,smu(1:2,1:2),snu(1:2,1:2)
zspv=2D0*(+smu(1,1)*snu(2,2)
. +smu(2,2)*snu(1,1)
. -smu(1,2)*snu(2,1)
. -smu(2,1)*snu(1,2) )
end
c
c
c spence function taking only real arguments
c
function rsp(x)
implicit double precision(a-h,o-z)
common/spint/a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,zeta2
x2=x*x
if(x.gt.1.D0)then
write(*,*)' argument greater than 1 passed to spence function'
rsp=0.D0
return
endif
if(x2.gt.1.D0.and.x.gt.0.5D0)then
y=(x-1.D0)/x
z=-log(1.D0-y)
z2=z*z
rsp=z*(1.D0+a1*z*(1.D0+a2*z*(1.D0+a3*z2*(1.D0+a4*z2*
1 (1.D0+a5*z2*(1.D0+a6*z2*(1.D0+a7*z2*(1.D0+a8*z2*(1.D0+a9*z2*
2 (1.D0+a10*z2))))))))))
3 +zeta2-log(x)*log(1.D0-x)+0.5D0*log(x)**2
return
elseif(x2.gt.1.D0.and.x.le.0.5D0)then
y=1.D0/x
z=-log(1.D0-y)
z2=z*z
rsp=-z*(1.D0+a1*z*(1.D0+a2*z*(1.D0+a3*z2*(1.D0+a4*z2*
1 (1.D0+a5*z2*(1.D0+a6*z2*(1.D0+a7*z2*(1.D0+a8*z2*(1.D0+a9*z2*
2 (1.D0+a10*z2))))))))))
3 -zeta2-0.5D0*log(-x)**2
return
elseif(x2.eq.1.D0)then
rsp=zeta2
return
elseif(x2.le.1.D0.and.x.gt.0.5D0)then
y=1.D0-x
z=-log(1.D0-y)
z2=z*z
rsp=-z*(1.D0+a1*z*(1.D0+a2*z*(1.D0+a3*z2*(1.D0+a4*z2*
1 (1.D0+a5*z2*(1.D0+a6*z2*(1.D0+a7*z2*(1.D0+a8*z2*(1.D0+a9*z2*
2 (1.D0+a10*z2))))))))))
3 +zeta2-log(x)*log(1.D0-x)
return
elseif(x2.le.1.D0.and.x.le.0.5D0)then
y=x
z=-log(1.D0-y)
z2=z*z
rsp=z*(1.D0+a1*z*(1.D0+a2*z*(1.D0+a3*z2*(1.D0+a4*z2*
1 (1.D0+a5*z2*(1.D0+a6*z2*(1.D0+a7*z2*(1.D0+a8*z2*(1.D0+a9*z2*
2 (1.D0+a10*z2))))))))))
return
else
write(*,*)' illegal x value in spence function'
rsp=0.D0
endif
return
end
c spence function
c
block data splint
implicit double precision (a-h,o-z)
common/spint/a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,zeta2
data a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,zeta2/
1 -0.250000000000000D0,
2 -0.111111111111111D0,
3 -0.010000000000000D0,
4 -0.017006802721088D0,
5 -0.019444444444444D0,
6 -0.020661157024793D0,
7 -0.021417300648069D0,
8 -0.021948866377231D0,
9 -0.022349233811171D0,
1 -0.022663689135191D0,
2 1.644934066848226D0/
end block data splint
c
c***********************************************************************
C-----------------------------------------------------------------------
C-----------------------------------------------------------------------
C-----------------------------------------------------------------------