← Back to branch summary

~madteam/mg5amcnlo/series2.0

« back to all changes in this revision

Viewing changes to tests/input_files/IOTestsComparison/MadLoop_output_from_the_interface/TIR_output/%ggttx_IOTest%SubProcesses%P0_gg_ttx%CT_interface.f

mwrge with 2.7.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/input_files/IOTestsComparison/MadLoop_output_from_the_interface/TIR_output/%ggttx_IOTest%SubProcesses%P0_gg_ttx%CT_interface.f
594
594
 
595
595
      END
596
596
 
597
 
      SUBROUTINE ML5_0_LOOP_2_3(P1, P2, W1, W2, W3, M1, M2,  RANK,
 
597
      SUBROUTINE ML5_0_LOOP_3(W1, W2, W3, M1, M2, M3,  RANK,
598
598
     $  SQUAREDSOINDEX, LOOPNUM)
599
599
      INTEGER    NEXTERNAL
600
600
      PARAMETER (NEXTERNAL=4)
601
601
      INTEGER    NLOOPLINE
602
 
      PARAMETER (NLOOPLINE=2)
 
602
      PARAMETER (NLOOPLINE=3)
603
603
      INTEGER    NWAVEFUNCS
604
604
      PARAMETER (NWAVEFUNCS=10)
605
605
      INTEGER    NLOOPGROUPS
613
613
C     ARGUMENTS 
614
614
C     
615
615
      INTEGER W1, W2, W3
616
 
      COMPLEX*16 M1, M2
617
 
      INTEGER P1, P2
 
616
      COMPLEX*16 M1, M2, M3
 
617
 
618
618
      INTEGER RANK, LSYMFACT
619
619
      INTEGER LOOPNUM, SQUAREDSOINDEX
620
620
C     
664
664
C     Determine it uses qp or not
665
665
      DOING_QP = (CTMODE.GE.4)
666
666
 
667
 
      IF (CHECKPHASE.OR.(.NOT.HELDOUBLECHECKED).OR.GOODAMP(SQUAREDSOIND
668
 
     $EX,LOOPNUM)) THEN
 
667
      IF (CHECKPHASE.OR.(.NOT.HELDOUBLECHECKED)
 
668
     $ .OR.GOODAMP(SQUAREDSOINDEX,LOOPNUM)) THEN
669
669
        WE(1)=W1
670
670
        WE(2)=W2
671
671
        WE(3)=W3
672
 
        M2L(1)=M2**2
 
672
        M2L(1)=M3**2
673
673
        M2L(2)=M1**2
674
 
        PAIRING(1)=P1
675
 
        PAIRING(2)=P2
 
674
        M2L(3)=M2**2
 
675
        DO I=1,NLOOPLINE
 
676
          PAIRING(I)=1
 
677
        ENDDO
 
678
 
676
679
        R=RANK
677
680
        ID=LOOPNUM
678
681
        SQSOINDEX=SQUAREDSOINDEX
806
809
C     Determine it uses qp or not
807
810
      DOING_QP = (CTMODE.GE.4)
808
811
 
809
 
      IF (CHECKPHASE.OR.(.NOT.HELDOUBLECHECKED).OR.GOODAMP(SQUAREDSOIND
810
 
     $EX,LOOPNUM)) THEN
 
812
      IF (CHECKPHASE.OR.(.NOT.HELDOUBLECHECKED)
 
813
     $ .OR.GOODAMP(SQUAREDSOINDEX,LOOPNUM)) THEN
811
814
        WE(1)=W1
812
815
        WE(2)=W2
813
816
        WE(3)=W3
883
886
      ENDIF
884
887
      END
885
888
 
 
889
      SUBROUTINE ML5_0_LOOP_2_3(P1, P2, W1, W2, W3, M1, M2,  RANK,
 
890
     $  SQUAREDSOINDEX, LOOPNUM)
 
891
      INTEGER    NEXTERNAL
 
892
      PARAMETER (NEXTERNAL=4)
 
893
      INTEGER    NLOOPLINE
 
894
      PARAMETER (NLOOPLINE=2)
 
895
      INTEGER    NWAVEFUNCS
 
896
      PARAMETER (NWAVEFUNCS=10)
 
897
      INTEGER    NLOOPGROUPS
 
898
      PARAMETER (NLOOPGROUPS=26)
 
899
      INTEGER    NCOMB
 
900
      PARAMETER (NCOMB=16)
 
901
C     These are constants related to the split orders
 
902
      INTEGER    NSQUAREDSO
 
903
      PARAMETER (NSQUAREDSO=1)
 
904
C     
 
905
C     ARGUMENTS 
 
906
C     
 
907
      INTEGER W1, W2, W3
 
908
      COMPLEX*16 M1, M2
 
909
      INTEGER P1, P2
 
910
      INTEGER RANK, LSYMFACT
 
911
      INTEGER LOOPNUM, SQUAREDSOINDEX
 
912
C     
 
913
C     LOCAL VARIABLES 
 
914
C     
 
915
      REAL*8 PL(0:3,NLOOPLINE)
 
916
      REAL*16 MP_PL(0:3,NLOOPLINE)
 
917
      COMPLEX*16 M2L(NLOOPLINE)
 
918
      INTEGER PAIRING(NLOOPLINE),WE(3)
 
919
      INTEGER I, J, K, TEMP,I_LIB
 
920
      LOGICAL COMPLEX_MASS,DOING_QP
 
921
C     
 
922
C     GLOBAL VARIABLES
 
923
C     
 
924
      INCLUDE 'MadLoopParams.inc'
 
925
      INTEGER ID,SQSOINDEX,R
 
926
      COMMON/ML5_0_LOOP/ID,SQSOINDEX,R
 
927
 
 
928
      LOGICAL CHECKPHASE, HELDOUBLECHECKED
 
929
      COMMON/ML5_0_INIT/CHECKPHASE, HELDOUBLECHECKED
 
930
 
 
931
      INTEGER HELOFFSET
 
932
      INTEGER GOODHEL(NCOMB)
 
933
      LOGICAL GOODAMP(NSQUAREDSO,NLOOPGROUPS)
 
934
      COMMON/ML5_0_FILTERS/GOODAMP,GOODHEL,HELOFFSET
 
935
 
 
936
      COMPLEX*16 LOOPRES(3,NSQUAREDSO,NLOOPGROUPS)
 
937
      LOGICAL S(NSQUAREDSO,NLOOPGROUPS)
 
938
      COMMON/ML5_0_LOOPRES/LOOPRES,S
 
939
 
 
940
 
 
941
      COMPLEX*16 W(20,NWAVEFUNCS)
 
942
      COMMON/ML5_0_W/W
 
943
      COMPLEX*32 MP_W(20,NWAVEFUNCS)
 
944
      COMMON/ML5_0_MP_W/MP_W
 
945
 
 
946
      REAL*8 LSCALE
 
947
      INTEGER CTMODE
 
948
      COMMON/ML5_0_CT/LSCALE,CTMODE
 
949
      INTEGER LIBINDEX
 
950
      COMMON/ML5_0_I_LIB/LIBINDEX
 
951
 
 
952
C     ----------
 
953
C     BEGIN CODE
 
954
C     ----------
 
955
 
 
956
C     Determine it uses qp or not
 
957
      DOING_QP = (CTMODE.GE.4)
 
958
 
 
959
      IF (CHECKPHASE.OR.(.NOT.HELDOUBLECHECKED)
 
960
     $ .OR.GOODAMP(SQUAREDSOINDEX,LOOPNUM)) THEN
 
961
        WE(1)=W1
 
962
        WE(2)=W2
 
963
        WE(3)=W3
 
964
        M2L(1)=M2**2
 
965
        M2L(2)=M1**2
 
966
        PAIRING(1)=P1
 
967
        PAIRING(2)=P2
 
968
        R=RANK
 
969
        ID=LOOPNUM
 
970
        SQSOINDEX=SQUAREDSOINDEX
 
971
        DO I=0,3
 
972
          TEMP=1
 
973
          DO J=1,NLOOPLINE
 
974
            PL(I,J)=0.D0
 
975
            IF (DOING_QP) THEN
 
976
              MP_PL(I,J)=0.0E+0_16
 
977
            ENDIF
 
978
            DO K=TEMP,(TEMP+PAIRING(J)-1)
 
979
              PL(I,J)=PL(I,J)-DBLE(W(1+I,WE(K)))
 
980
              IF (DOING_QP) THEN
 
981
                MP_PL(I,J)=MP_PL(I,J)-REAL(MP_W(1+I,WE(K)),KIND=16)
 
982
              ENDIF
 
983
            ENDDO
 
984
            TEMP=TEMP+PAIRING(J)
 
985
          ENDDO
 
986
        ENDDO
 
987
C       Determine whether the integral is with complex masses or not
 
988
C       since some reduction libraries, e.g.PJFry++ and IREGI, are
 
989
C        still
 
990
C       not able to deal with complex masses
 
991
        COMPLEX_MASS=.FALSE.
 
992
        DO I=1,NLOOPLINE
 
993
          IF(DIMAG(M2L(I)).EQ.0D0)CYCLE
 
994
          IF(ABS(DIMAG(M2L(I)))/MAX(ABS(M2L(I)),1D-2).GT.1D-15)THEN
 
995
            COMPLEX_MASS=.TRUE.
 
996
            EXIT
 
997
          ENDIF
 
998
        ENDDO
 
999
C       Choose the correct loop library
 
1000
        CALL ML5_0_CHOOSE_LOOPLIB(LIBINDEX,NLOOPLINE,RANK,COMPLEX_MASS
 
1001
     $   ,ID,DOING_QP,I_LIB)
 
1002
        IF(MLREDUCTIONLIB(I_LIB).EQ.1)THEN
 
1003
C         CutTools is used
 
1004
          CALL ML5_0_CTLOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1
 
1005
     $     ,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
 
1006
        ELSEIF (MLREDUCTIONLIB(I_LIB).EQ.6) THEN
 
1007
C         Ninja is used
 
1008
          IF (.NOT.DOING_QP) THEN
 
1009
            CALL ML5_0_NINJA_LOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1
 
1010
     $       ,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
 
1011
          ELSE
 
1012
            WRITE(*,*) 'ERROR: Ninja should not be called in quadruple'
 
1013
     $       //' precision since the installed version considered does'
 
1014
     $       //' not support it.'
 
1015
            STOP 9
 
1016
          ENDIF
 
1017
        ELSE
 
1018
C         Tensor Integral Reduction is used 
 
1019
          CALL ML5_0_TIRLOOP(SQUAREDSOINDEX,LOOPNUM,I_LIB,NLOOPLINE,PL
 
1020
     $     ,M2L,RANK,LOOPRES(1,SQUAREDSOINDEX,LOOPNUM)
 
1021
     $     ,S(SQUAREDSOINDEX,LOOPNUM))
 
1022
        ENDIF
 
1023
      ELSE
 
1024
        LOOPRES(1,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
 
1025
        LOOPRES(2,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
 
1026
        LOOPRES(3,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
 
1027
        S(SQUAREDSOINDEX,LOOPNUM)=.TRUE.
 
1028
      ENDIF
 
1029
      END
 
1030
 
 
1031
      SUBROUTINE ML5_0_LOOP_2(W1, W2, M1, M2,  RANK, SQUAREDSOINDEX,
 
1032
     $  LOOPNUM)
 
1033
      INTEGER    NEXTERNAL
 
1034
      PARAMETER (NEXTERNAL=4)
 
1035
      INTEGER    NLOOPLINE
 
1036
      PARAMETER (NLOOPLINE=2)
 
1037
      INTEGER    NWAVEFUNCS
 
1038
      PARAMETER (NWAVEFUNCS=10)
 
1039
      INTEGER    NLOOPGROUPS
 
1040
      PARAMETER (NLOOPGROUPS=26)
 
1041
      INTEGER    NCOMB
 
1042
      PARAMETER (NCOMB=16)
 
1043
C     These are constants related to the split orders
 
1044
      INTEGER    NSQUAREDSO
 
1045
      PARAMETER (NSQUAREDSO=1)
 
1046
C     
 
1047
C     ARGUMENTS 
 
1048
C     
 
1049
      INTEGER W1, W2
 
1050
      COMPLEX*16 M1, M2
 
1051
 
 
1052
      INTEGER RANK, LSYMFACT
 
1053
      INTEGER LOOPNUM, SQUAREDSOINDEX
 
1054
C     
 
1055
C     LOCAL VARIABLES 
 
1056
C     
 
1057
      REAL*8 PL(0:3,NLOOPLINE)
 
1058
      REAL*16 MP_PL(0:3,NLOOPLINE)
 
1059
      COMPLEX*16 M2L(NLOOPLINE)
 
1060
      INTEGER PAIRING(NLOOPLINE),WE(2)
 
1061
      INTEGER I, J, K, TEMP,I_LIB
 
1062
      LOGICAL COMPLEX_MASS,DOING_QP
 
1063
C     
 
1064
C     GLOBAL VARIABLES
 
1065
C     
 
1066
      INCLUDE 'MadLoopParams.inc'
 
1067
      INTEGER ID,SQSOINDEX,R
 
1068
      COMMON/ML5_0_LOOP/ID,SQSOINDEX,R
 
1069
 
 
1070
      LOGICAL CHECKPHASE, HELDOUBLECHECKED
 
1071
      COMMON/ML5_0_INIT/CHECKPHASE, HELDOUBLECHECKED
 
1072
 
 
1073
      INTEGER HELOFFSET
 
1074
      INTEGER GOODHEL(NCOMB)
 
1075
      LOGICAL GOODAMP(NSQUAREDSO,NLOOPGROUPS)
 
1076
      COMMON/ML5_0_FILTERS/GOODAMP,GOODHEL,HELOFFSET
 
1077
 
 
1078
      COMPLEX*16 LOOPRES(3,NSQUAREDSO,NLOOPGROUPS)
 
1079
      LOGICAL S(NSQUAREDSO,NLOOPGROUPS)
 
1080
      COMMON/ML5_0_LOOPRES/LOOPRES,S
 
1081
 
 
1082
 
 
1083
      COMPLEX*16 W(20,NWAVEFUNCS)
 
1084
      COMMON/ML5_0_W/W
 
1085
      COMPLEX*32 MP_W(20,NWAVEFUNCS)
 
1086
      COMMON/ML5_0_MP_W/MP_W
 
1087
 
 
1088
      REAL*8 LSCALE
 
1089
      INTEGER CTMODE
 
1090
      COMMON/ML5_0_CT/LSCALE,CTMODE
 
1091
      INTEGER LIBINDEX
 
1092
      COMMON/ML5_0_I_LIB/LIBINDEX
 
1093
 
 
1094
C     ----------
 
1095
C     BEGIN CODE
 
1096
C     ----------
 
1097
 
 
1098
C     Determine it uses qp or not
 
1099
      DOING_QP = (CTMODE.GE.4)
 
1100
 
 
1101
      IF (CHECKPHASE.OR.(.NOT.HELDOUBLECHECKED)
 
1102
     $ .OR.GOODAMP(SQUAREDSOINDEX,LOOPNUM)) THEN
 
1103
        WE(1)=W1
 
1104
        WE(2)=W2
 
1105
        M2L(1)=M2**2
 
1106
        M2L(2)=M1**2
 
1107
        DO I=1,NLOOPLINE
 
1108
          PAIRING(I)=1
 
1109
        ENDDO
 
1110
 
 
1111
        R=RANK
 
1112
        ID=LOOPNUM
 
1113
        SQSOINDEX=SQUAREDSOINDEX
 
1114
        DO I=0,3
 
1115
          TEMP=1
 
1116
          DO J=1,NLOOPLINE
 
1117
            PL(I,J)=0.D0
 
1118
            IF (DOING_QP) THEN
 
1119
              MP_PL(I,J)=0.0E+0_16
 
1120
            ENDIF
 
1121
            DO K=TEMP,(TEMP+PAIRING(J)-1)
 
1122
              PL(I,J)=PL(I,J)-DBLE(W(1+I,WE(K)))
 
1123
              IF (DOING_QP) THEN
 
1124
                MP_PL(I,J)=MP_PL(I,J)-REAL(MP_W(1+I,WE(K)),KIND=16)
 
1125
              ENDIF
 
1126
            ENDDO
 
1127
            TEMP=TEMP+PAIRING(J)
 
1128
          ENDDO
 
1129
        ENDDO
 
1130
C       Determine whether the integral is with complex masses or not
 
1131
C       since some reduction libraries, e.g.PJFry++ and IREGI, are
 
1132
C        still
 
1133
C       not able to deal with complex masses
 
1134
        COMPLEX_MASS=.FALSE.
 
1135
        DO I=1,NLOOPLINE
 
1136
          IF(DIMAG(M2L(I)).EQ.0D0)CYCLE
 
1137
          IF(ABS(DIMAG(M2L(I)))/MAX(ABS(M2L(I)),1D-2).GT.1D-15)THEN
 
1138
            COMPLEX_MASS=.TRUE.
 
1139
            EXIT
 
1140
          ENDIF
 
1141
        ENDDO
 
1142
C       Choose the correct loop library
 
1143
        CALL ML5_0_CHOOSE_LOOPLIB(LIBINDEX,NLOOPLINE,RANK,COMPLEX_MASS
 
1144
     $   ,ID,DOING_QP,I_LIB)
 
1145
        IF(MLREDUCTIONLIB(I_LIB).EQ.1)THEN
 
1146
C         CutTools is used
 
1147
          CALL ML5_0_CTLOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1
 
1148
     $     ,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
 
1149
        ELSEIF (MLREDUCTIONLIB(I_LIB).EQ.6) THEN
 
1150
C         Ninja is used
 
1151
          IF (.NOT.DOING_QP) THEN
 
1152
            CALL ML5_0_NINJA_LOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1
 
1153
     $       ,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
 
1154
          ELSE
 
1155
            WRITE(*,*) 'ERROR: Ninja should not be called in quadruple'
 
1156
     $       //' precision since the installed version considered does'
 
1157
     $       //' not support it.'
 
1158
            STOP 9
 
1159
          ENDIF
 
1160
        ELSE
 
1161
C         Tensor Integral Reduction is used 
 
1162
          CALL ML5_0_TIRLOOP(SQUAREDSOINDEX,LOOPNUM,I_LIB,NLOOPLINE,PL
 
1163
     $     ,M2L,RANK,LOOPRES(1,SQUAREDSOINDEX,LOOPNUM)
 
1164
     $     ,S(SQUAREDSOINDEX,LOOPNUM))
 
1165
        ENDIF
 
1166
      ELSE
 
1167
        LOOPRES(1,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
 
1168
        LOOPRES(2,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
 
1169
        LOOPRES(3,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
 
1170
        S(SQUAREDSOINDEX,LOOPNUM)=.TRUE.
 
1171
      ENDIF
 
1172
      END
 
1173
 
886
1174
      SUBROUTINE ML5_0_LOOP_3_4(P1, P2, P3, W1, W2, W3, W4, M1, M2, M3
887
1175
     $ ,  RANK, SQUAREDSOINDEX, LOOPNUM)
888
1176
      INTEGER    NEXTERNAL
953
1241
C     Determine it uses qp or not
954
1242
      DOING_QP = (CTMODE.GE.4)
955
1243
 
956
 
      IF (CHECKPHASE.OR.(.NOT.HELDOUBLECHECKED).OR.GOODAMP(SQUAREDSOIND
957
 
     $EX,LOOPNUM)) THEN
 
1244
      IF (CHECKPHASE.OR.(.NOT.HELDOUBLECHECKED)
 
1245
     $ .OR.GOODAMP(SQUAREDSOINDEX,LOOPNUM)) THEN
958
1246
        WE(1)=W1
959
1247
        WE(2)=W2
960
1248
        WE(3)=W3
1028
1316
      ENDIF
1029
1317
      END
1030
1318
 
1031
 
      SUBROUTINE ML5_0_LOOP_3(W1, W2, W3, M1, M2, M3,  RANK,
1032
 
     $  SQUAREDSOINDEX, LOOPNUM)
1033
 
      INTEGER    NEXTERNAL
1034
 
      PARAMETER (NEXTERNAL=4)
1035
 
      INTEGER    NLOOPLINE
1036
 
      PARAMETER (NLOOPLINE=3)
1037
 
      INTEGER    NWAVEFUNCS
1038
 
      PARAMETER (NWAVEFUNCS=10)
1039
 
      INTEGER    NLOOPGROUPS
1040
 
      PARAMETER (NLOOPGROUPS=26)
1041
 
      INTEGER    NCOMB
1042
 
      PARAMETER (NCOMB=16)
1043
 
C     These are constants related to the split orders
1044
 
      INTEGER    NSQUAREDSO
1045
 
      PARAMETER (NSQUAREDSO=1)
1046
 
C     
1047
 
C     ARGUMENTS 
1048
 
C     
1049
 
      INTEGER W1, W2, W3
1050
 
      COMPLEX*16 M1, M2, M3
1051
 
 
1052
 
      INTEGER RANK, LSYMFACT
1053
 
      INTEGER LOOPNUM, SQUAREDSOINDEX
1054
 
C     
1055
 
C     LOCAL VARIABLES 
1056
 
C     
1057
 
      REAL*8 PL(0:3,NLOOPLINE)
1058
 
      REAL*16 MP_PL(0:3,NLOOPLINE)
1059
 
      COMPLEX*16 M2L(NLOOPLINE)
1060
 
      INTEGER PAIRING(NLOOPLINE),WE(3)
1061
 
      INTEGER I, J, K, TEMP,I_LIB
1062
 
      LOGICAL COMPLEX_MASS,DOING_QP
1063
 
C     
1064
 
C     GLOBAL VARIABLES
1065
 
C     
1066
 
      INCLUDE 'MadLoopParams.inc'
1067
 
      INTEGER ID,SQSOINDEX,R
1068
 
      COMMON/ML5_0_LOOP/ID,SQSOINDEX,R
1069
 
 
1070
 
      LOGICAL CHECKPHASE, HELDOUBLECHECKED
1071
 
      COMMON/ML5_0_INIT/CHECKPHASE, HELDOUBLECHECKED
1072
 
 
1073
 
      INTEGER HELOFFSET
1074
 
      INTEGER GOODHEL(NCOMB)
1075
 
      LOGICAL GOODAMP(NSQUAREDSO,NLOOPGROUPS)
1076
 
      COMMON/ML5_0_FILTERS/GOODAMP,GOODHEL,HELOFFSET
1077
 
 
1078
 
      COMPLEX*16 LOOPRES(3,NSQUAREDSO,NLOOPGROUPS)
1079
 
      LOGICAL S(NSQUAREDSO,NLOOPGROUPS)
1080
 
      COMMON/ML5_0_LOOPRES/LOOPRES,S
1081
 
 
1082
 
 
1083
 
      COMPLEX*16 W(20,NWAVEFUNCS)
1084
 
      COMMON/ML5_0_W/W
1085
 
      COMPLEX*32 MP_W(20,NWAVEFUNCS)
1086
 
      COMMON/ML5_0_MP_W/MP_W
1087
 
 
1088
 
      REAL*8 LSCALE
1089
 
      INTEGER CTMODE
1090
 
      COMMON/ML5_0_CT/LSCALE,CTMODE
1091
 
      INTEGER LIBINDEX
1092
 
      COMMON/ML5_0_I_LIB/LIBINDEX
1093
 
 
1094
 
C     ----------
1095
 
C     BEGIN CODE
1096
 
C     ----------
1097
 
 
1098
 
C     Determine it uses qp or not
1099
 
      DOING_QP = (CTMODE.GE.4)
1100
 
 
1101
 
      IF (CHECKPHASE.OR.(.NOT.HELDOUBLECHECKED).OR.GOODAMP(SQUAREDSOIND
1102
 
     $EX,LOOPNUM)) THEN
1103
 
        WE(1)=W1
1104
 
        WE(2)=W2
1105
 
        WE(3)=W3
1106
 
        M2L(1)=M3**2
1107
 
        M2L(2)=M1**2
1108
 
        M2L(3)=M2**2
1109
 
        DO I=1,NLOOPLINE
1110
 
          PAIRING(I)=1
1111
 
        ENDDO
1112
 
 
1113
 
        R=RANK
1114
 
        ID=LOOPNUM
1115
 
        SQSOINDEX=SQUAREDSOINDEX
1116
 
        DO I=0,3
1117
 
          TEMP=1
1118
 
          DO J=1,NLOOPLINE
1119
 
            PL(I,J)=0.D0
1120
 
            IF (DOING_QP) THEN
1121
 
              MP_PL(I,J)=0.0E+0_16
1122
 
            ENDIF
1123
 
            DO K=TEMP,(TEMP+PAIRING(J)-1)
1124
 
              PL(I,J)=PL(I,J)-DBLE(W(1+I,WE(K)))
1125
 
              IF (DOING_QP) THEN
1126
 
                MP_PL(I,J)=MP_PL(I,J)-REAL(MP_W(1+I,WE(K)),KIND=16)
1127
 
              ENDIF
1128
 
            ENDDO
1129
 
            TEMP=TEMP+PAIRING(J)
1130
 
          ENDDO
1131
 
        ENDDO
1132
 
C       Determine whether the integral is with complex masses or not
1133
 
C       since some reduction libraries, e.g.PJFry++ and IREGI, are
1134
 
C        still
1135
 
C       not able to deal with complex masses
1136
 
        COMPLEX_MASS=.FALSE.
1137
 
        DO I=1,NLOOPLINE
1138
 
          IF(DIMAG(M2L(I)).EQ.0D0)CYCLE
1139
 
          IF(ABS(DIMAG(M2L(I)))/MAX(ABS(M2L(I)),1D-2).GT.1D-15)THEN
1140
 
            COMPLEX_MASS=.TRUE.
1141
 
            EXIT
1142
 
          ENDIF
1143
 
        ENDDO
1144
 
C       Choose the correct loop library
1145
 
        CALL ML5_0_CHOOSE_LOOPLIB(LIBINDEX,NLOOPLINE,RANK,COMPLEX_MASS
1146
 
     $   ,ID,DOING_QP,I_LIB)
1147
 
        IF(MLREDUCTIONLIB(I_LIB).EQ.1)THEN
1148
 
C         CutTools is used
1149
 
          CALL ML5_0_CTLOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1
1150
 
     $     ,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
1151
 
        ELSEIF (MLREDUCTIONLIB(I_LIB).EQ.6) THEN
1152
 
C         Ninja is used
1153
 
          IF (.NOT.DOING_QP) THEN
1154
 
            CALL ML5_0_NINJA_LOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1
1155
 
     $       ,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
1156
 
          ELSE
1157
 
            WRITE(*,*) 'ERROR: Ninja should not be called in quadruple'
1158
 
     $       //' precision since the installed version considered does'
1159
 
     $       //' not support it.'
1160
 
            STOP 9
1161
 
          ENDIF
1162
 
        ELSE
1163
 
C         Tensor Integral Reduction is used 
1164
 
          CALL ML5_0_TIRLOOP(SQUAREDSOINDEX,LOOPNUM,I_LIB,NLOOPLINE,PL
1165
 
     $     ,M2L,RANK,LOOPRES(1,SQUAREDSOINDEX,LOOPNUM)
1166
 
     $     ,S(SQUAREDSOINDEX,LOOPNUM))
1167
 
        ENDIF
1168
 
      ELSE
1169
 
        LOOPRES(1,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
1170
 
        LOOPRES(2,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
1171
 
        LOOPRES(3,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
1172
 
        S(SQUAREDSOINDEX,LOOPNUM)=.TRUE.
1173
 
      ENDIF
1174
 
      END
1175
 
 
1176
 
      SUBROUTINE ML5_0_LOOP_2(W1, W2, M1, M2,  RANK, SQUAREDSOINDEX,
1177
 
     $  LOOPNUM)
1178
 
      INTEGER    NEXTERNAL
1179
 
      PARAMETER (NEXTERNAL=4)
1180
 
      INTEGER    NLOOPLINE
1181
 
      PARAMETER (NLOOPLINE=2)
1182
 
      INTEGER    NWAVEFUNCS
1183
 
      PARAMETER (NWAVEFUNCS=10)
1184
 
      INTEGER    NLOOPGROUPS
1185
 
      PARAMETER (NLOOPGROUPS=26)
1186
 
      INTEGER    NCOMB
1187
 
      PARAMETER (NCOMB=16)
1188
 
C     These are constants related to the split orders
1189
 
      INTEGER    NSQUAREDSO
1190
 
      PARAMETER (NSQUAREDSO=1)
1191
 
C     
1192
 
C     ARGUMENTS 
1193
 
C     
1194
 
      INTEGER W1, W2
1195
 
      COMPLEX*16 M1, M2
1196
 
 
1197
 
      INTEGER RANK, LSYMFACT
1198
 
      INTEGER LOOPNUM, SQUAREDSOINDEX
1199
 
C     
1200
 
C     LOCAL VARIABLES 
1201
 
C     
1202
 
      REAL*8 PL(0:3,NLOOPLINE)
1203
 
      REAL*16 MP_PL(0:3,NLOOPLINE)
1204
 
      COMPLEX*16 M2L(NLOOPLINE)
1205
 
      INTEGER PAIRING(NLOOPLINE),WE(2)
1206
 
      INTEGER I, J, K, TEMP,I_LIB
1207
 
      LOGICAL COMPLEX_MASS,DOING_QP
1208
 
C     
1209
 
C     GLOBAL VARIABLES
1210
 
C     
1211
 
      INCLUDE 'MadLoopParams.inc'
1212
 
      INTEGER ID,SQSOINDEX,R
1213
 
      COMMON/ML5_0_LOOP/ID,SQSOINDEX,R
1214
 
 
1215
 
      LOGICAL CHECKPHASE, HELDOUBLECHECKED
1216
 
      COMMON/ML5_0_INIT/CHECKPHASE, HELDOUBLECHECKED
1217
 
 
1218
 
      INTEGER HELOFFSET
1219
 
      INTEGER GOODHEL(NCOMB)
1220
 
      LOGICAL GOODAMP(NSQUAREDSO,NLOOPGROUPS)
1221
 
      COMMON/ML5_0_FILTERS/GOODAMP,GOODHEL,HELOFFSET
1222
 
 
1223
 
      COMPLEX*16 LOOPRES(3,NSQUAREDSO,NLOOPGROUPS)
1224
 
      LOGICAL S(NSQUAREDSO,NLOOPGROUPS)
1225
 
      COMMON/ML5_0_LOOPRES/LOOPRES,S
1226
 
 
1227
 
 
1228
 
      COMPLEX*16 W(20,NWAVEFUNCS)
1229
 
      COMMON/ML5_0_W/W
1230
 
      COMPLEX*32 MP_W(20,NWAVEFUNCS)
1231
 
      COMMON/ML5_0_MP_W/MP_W
1232
 
 
1233
 
      REAL*8 LSCALE
1234
 
      INTEGER CTMODE
1235
 
      COMMON/ML5_0_CT/LSCALE,CTMODE
1236
 
      INTEGER LIBINDEX
1237
 
      COMMON/ML5_0_I_LIB/LIBINDEX
1238
 
 
1239
 
C     ----------
1240
 
C     BEGIN CODE
1241
 
C     ----------
1242
 
 
1243
 
C     Determine it uses qp or not
1244
 
      DOING_QP = (CTMODE.GE.4)
1245
 
 
1246
 
      IF (CHECKPHASE.OR.(.NOT.HELDOUBLECHECKED).OR.GOODAMP(SQUAREDSOIND
1247
 
     $EX,LOOPNUM)) THEN
1248
 
        WE(1)=W1
1249
 
        WE(2)=W2
1250
 
        M2L(1)=M2**2
1251
 
        M2L(2)=M1**2
1252
 
        DO I=1,NLOOPLINE
1253
 
          PAIRING(I)=1
1254
 
        ENDDO
1255
 
 
1256
 
        R=RANK
1257
 
        ID=LOOPNUM
1258
 
        SQSOINDEX=SQUAREDSOINDEX
1259
 
        DO I=0,3
1260
 
          TEMP=1
1261
 
          DO J=1,NLOOPLINE
1262
 
            PL(I,J)=0.D0
1263
 
            IF (DOING_QP) THEN
1264
 
              MP_PL(I,J)=0.0E+0_16
1265
 
            ENDIF
1266
 
            DO K=TEMP,(TEMP+PAIRING(J)-1)
1267
 
              PL(I,J)=PL(I,J)-DBLE(W(1+I,WE(K)))
1268
 
              IF (DOING_QP) THEN
1269
 
                MP_PL(I,J)=MP_PL(I,J)-REAL(MP_W(1+I,WE(K)),KIND=16)
1270
 
              ENDIF
1271
 
            ENDDO
1272
 
            TEMP=TEMP+PAIRING(J)
1273
 
          ENDDO
1274
 
        ENDDO
1275
 
C       Determine whether the integral is with complex masses or not
1276
 
C       since some reduction libraries, e.g.PJFry++ and IREGI, are
1277
 
C        still
1278
 
C       not able to deal with complex masses
1279
 
        COMPLEX_MASS=.FALSE.
1280
 
        DO I=1,NLOOPLINE
1281
 
          IF(DIMAG(M2L(I)).EQ.0D0)CYCLE
1282
 
          IF(ABS(DIMAG(M2L(I)))/MAX(ABS(M2L(I)),1D-2).GT.1D-15)THEN
1283
 
            COMPLEX_MASS=.TRUE.
1284
 
            EXIT
1285
 
          ENDIF
1286
 
        ENDDO
1287
 
C       Choose the correct loop library
1288
 
        CALL ML5_0_CHOOSE_LOOPLIB(LIBINDEX,NLOOPLINE,RANK,COMPLEX_MASS
1289
 
     $   ,ID,DOING_QP,I_LIB)
1290
 
        IF(MLREDUCTIONLIB(I_LIB).EQ.1)THEN
1291
 
C         CutTools is used
1292
 
          CALL ML5_0_CTLOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1
1293
 
     $     ,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
1294
 
        ELSEIF (MLREDUCTIONLIB(I_LIB).EQ.6) THEN
1295
 
C         Ninja is used
1296
 
          IF (.NOT.DOING_QP) THEN
1297
 
            CALL ML5_0_NINJA_LOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1
1298
 
     $       ,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
1299
 
          ELSE
1300
 
            WRITE(*,*) 'ERROR: Ninja should not be called in quadruple'
1301
 
     $       //' precision since the installed version considered does'
1302
 
     $       //' not support it.'
1303
 
            STOP 9
1304
 
          ENDIF
1305
 
        ELSE
1306
 
C         Tensor Integral Reduction is used 
1307
 
          CALL ML5_0_TIRLOOP(SQUAREDSOINDEX,LOOPNUM,I_LIB,NLOOPLINE,PL
1308
 
     $     ,M2L,RANK,LOOPRES(1,SQUAREDSOINDEX,LOOPNUM)
1309
 
     $     ,S(SQUAREDSOINDEX,LOOPNUM))
1310
 
        ENDIF
1311
 
      ELSE
1312
 
        LOOPRES(1,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
1313
 
        LOOPRES(2,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
1314
 
        LOOPRES(3,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
1315
 
        S(SQUAREDSOINDEX,LOOPNUM)=.TRUE.
1316
 
      ENDIF
1317
 
      END
1318