← Back to branch summary

~maddevelopers/mg5amcnlo/simple_unlops

« back to all changes in this revision

Viewing changes to tests/input_files/IOTestsComparison/IOExportFKSTest/test_wprod_fksew/%SubProcesses%P0_dxu_veep%V0_dxu_veep%CT_interface.f

  • Committer: olivier-mattelaer
  • Date: 2021-11-12 09:29:31 UTC
  • mfrom: (967.1.15 3.3.0)
  • Revision ID: olivier-mattelaer-20211112092931-4ec9qfzgxkeovqog
version 3.3.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/input_files/IOTestsComparison/IOExportFKSTest/test_wprod_fksew/%SubProcesses%P0_dxu_veep%V0_dxu_veep%CT_interface.f
593
593
 
594
594
      END
595
595
 
 
596
      SUBROUTINE LOOP_2(W1, W2, M1, M2,  RANK, SQUAREDSOINDEX, LOOPNUM)
 
597
      INTEGER    NEXTERNAL
 
598
      PARAMETER (NEXTERNAL=4)
 
599
      INTEGER    NLOOPLINE
 
600
      PARAMETER (NLOOPLINE=2)
 
601
      INTEGER    NWAVEFUNCS
 
602
      PARAMETER (NWAVEFUNCS=6)
 
603
      INTEGER    NLOOPGROUPS
 
604
      PARAMETER (NLOOPGROUPS=25)
 
605
      INTEGER    NCOMB
 
606
      PARAMETER (NCOMB=16)
 
607
C     These are constants related to the split orders
 
608
      INTEGER    NSQUAREDSO
 
609
      PARAMETER (NSQUAREDSO=1)
 
610
C     
 
611
C     ARGUMENTS 
 
612
C     
 
613
      INTEGER W1, W2
 
614
      COMPLEX*16 M1, M2
 
615
 
 
616
      INTEGER RANK, LSYMFACT
 
617
      INTEGER LOOPNUM, SQUAREDSOINDEX
 
618
C     
 
619
C     LOCAL VARIABLES 
 
620
C     
 
621
      REAL*8 PL(0:3,NLOOPLINE)
 
622
      REAL*16 MP_PL(0:3,NLOOPLINE)
 
623
      COMPLEX*16 M2L(NLOOPLINE)
 
624
      INTEGER PAIRING(NLOOPLINE),WE(2)
 
625
      INTEGER I, J, K, TEMP,I_LIB
 
626
      LOGICAL COMPLEX_MASS,DOING_QP
 
627
C     
 
628
C     GLOBAL VARIABLES
 
629
C     
 
630
      INCLUDE 'MadLoopParams.inc'
 
631
      INTEGER ID,SQSOINDEX,R
 
632
      COMMON/LOOP/ID,SQSOINDEX,R
 
633
 
 
634
      LOGICAL CHECKPHASE, HELDOUBLECHECKED
 
635
      COMMON/INIT/CHECKPHASE, HELDOUBLECHECKED
 
636
 
 
637
      INTEGER HELOFFSET
 
638
      INTEGER GOODHEL(NCOMB)
 
639
      LOGICAL GOODAMP(NSQUAREDSO,NLOOPGROUPS)
 
640
      COMMON/FILTERS/GOODAMP,GOODHEL,HELOFFSET
 
641
 
 
642
      COMPLEX*16 LOOPRES(3,NSQUAREDSO,NLOOPGROUPS)
 
643
      LOGICAL S(NSQUAREDSO,NLOOPGROUPS)
 
644
      COMMON/LOOPRES/LOOPRES,S
 
645
 
 
646
 
 
647
      COMPLEX*16 W(20,NWAVEFUNCS)
 
648
      COMMON/W/W
 
649
      COMPLEX*32 MP_W(20,NWAVEFUNCS)
 
650
      COMMON/MP_W/MP_W
 
651
 
 
652
      REAL*8 LSCALE
 
653
      INTEGER CTMODE
 
654
      COMMON/CT/LSCALE,CTMODE
 
655
      INTEGER LIBINDEX
 
656
      COMMON/I_LIB/LIBINDEX
 
657
 
 
658
C     ----------
 
659
C     BEGIN CODE
 
660
C     ----------
 
661
 
 
662
C     Determine it uses qp or not
 
663
      DOING_QP = (CTMODE.GE.4)
 
664
 
 
665
      IF (CHECKPHASE.OR.(.NOT.HELDOUBLECHECKED)
 
666
     $ .OR.GOODAMP(SQUAREDSOINDEX,LOOPNUM)) THEN
 
667
        WE(1)=W1
 
668
        WE(2)=W2
 
669
        M2L(1)=M2**2
 
670
        M2L(2)=M1**2
 
671
        DO I=1,NLOOPLINE
 
672
          PAIRING(I)=1
 
673
        ENDDO
 
674
 
 
675
        R=RANK
 
676
        ID=LOOPNUM
 
677
        SQSOINDEX=SQUAREDSOINDEX
 
678
        DO I=0,3
 
679
          TEMP=1
 
680
          DO J=1,NLOOPLINE
 
681
            PL(I,J)=0.D0
 
682
            IF (DOING_QP) THEN
 
683
              MP_PL(I,J)=0.0E+0_16
 
684
            ENDIF
 
685
            DO K=TEMP,(TEMP+PAIRING(J)-1)
 
686
              PL(I,J)=PL(I,J)-DBLE(W(1+I,WE(K)))
 
687
              IF (DOING_QP) THEN
 
688
                MP_PL(I,J)=MP_PL(I,J)-REAL(MP_W(1+I,WE(K)),KIND=16)
 
689
              ENDIF
 
690
            ENDDO
 
691
            TEMP=TEMP+PAIRING(J)
 
692
          ENDDO
 
693
        ENDDO
 
694
C       Determine whether the integral is with complex masses or not
 
695
C       since some reduction libraries, e.g.PJFry++ and IREGI, are
 
696
C        still
 
697
C       not able to deal with complex masses
 
698
        COMPLEX_MASS=.FALSE.
 
699
        DO I=1,NLOOPLINE
 
700
          IF(DIMAG(M2L(I)).EQ.0D0)CYCLE
 
701
          IF(ABS(DIMAG(M2L(I)))/MAX(ABS(M2L(I)),1D-2).GT.1D-15)THEN
 
702
            COMPLEX_MASS=.TRUE.
 
703
            EXIT
 
704
          ENDIF
 
705
        ENDDO
 
706
C       Choose the correct loop library
 
707
        CALL CHOOSE_LOOPLIB(LIBINDEX,NLOOPLINE,RANK,COMPLEX_MASS,ID
 
708
     $   ,DOING_QP,I_LIB)
 
709
        IF(MLREDUCTIONLIB(I_LIB).EQ.1)THEN
 
710
C         CutTools is used
 
711
          CALL CTLOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1,SQUAREDSOINDEX
 
712
     $     ,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
 
713
        ELSEIF (MLREDUCTIONLIB(I_LIB).EQ.6) THEN
 
714
C         Ninja is used
 
715
          IF (.NOT.DOING_QP) THEN
 
716
            CALL NINJA_LOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1
 
717
     $       ,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
 
718
          ELSE
 
719
            WRITE(*,*) 'ERROR: Ninja should not be called in quadruple'
 
720
     $       //' precision since the installed version considered does'
 
721
     $       //' not support it.'
 
722
            STOP 9
 
723
          ENDIF
 
724
        ELSE
 
725
C         Tensor Integral Reduction is used 
 
726
          CALL TIRLOOP(SQUAREDSOINDEX,LOOPNUM,I_LIB,NLOOPLINE,PL,M2L
 
727
     $     ,RANK,LOOPRES(1,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX
 
728
     $     ,LOOPNUM))
 
729
        ENDIF
 
730
      ELSE
 
731
        LOOPRES(1,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
 
732
        LOOPRES(2,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
 
733
        LOOPRES(3,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
 
734
        S(SQUAREDSOINDEX,LOOPNUM)=.TRUE.
 
735
      ENDIF
 
736
      END
 
737
 
 
738
      SUBROUTINE LOOP_3(W1, W2, W3, M1, M2, M3,  RANK, SQUAREDSOINDEX,
 
739
     $  LOOPNUM)
 
740
      INTEGER    NEXTERNAL
 
741
      PARAMETER (NEXTERNAL=4)
 
742
      INTEGER    NLOOPLINE
 
743
      PARAMETER (NLOOPLINE=3)
 
744
      INTEGER    NWAVEFUNCS
 
745
      PARAMETER (NWAVEFUNCS=6)
 
746
      INTEGER    NLOOPGROUPS
 
747
      PARAMETER (NLOOPGROUPS=25)
 
748
      INTEGER    NCOMB
 
749
      PARAMETER (NCOMB=16)
 
750
C     These are constants related to the split orders
 
751
      INTEGER    NSQUAREDSO
 
752
      PARAMETER (NSQUAREDSO=1)
 
753
C     
 
754
C     ARGUMENTS 
 
755
C     
 
756
      INTEGER W1, W2, W3
 
757
      COMPLEX*16 M1, M2, M3
 
758
 
 
759
      INTEGER RANK, LSYMFACT
 
760
      INTEGER LOOPNUM, SQUAREDSOINDEX
 
761
C     
 
762
C     LOCAL VARIABLES 
 
763
C     
 
764
      REAL*8 PL(0:3,NLOOPLINE)
 
765
      REAL*16 MP_PL(0:3,NLOOPLINE)
 
766
      COMPLEX*16 M2L(NLOOPLINE)
 
767
      INTEGER PAIRING(NLOOPLINE),WE(3)
 
768
      INTEGER I, J, K, TEMP,I_LIB
 
769
      LOGICAL COMPLEX_MASS,DOING_QP
 
770
C     
 
771
C     GLOBAL VARIABLES
 
772
C     
 
773
      INCLUDE 'MadLoopParams.inc'
 
774
      INTEGER ID,SQSOINDEX,R
 
775
      COMMON/LOOP/ID,SQSOINDEX,R
 
776
 
 
777
      LOGICAL CHECKPHASE, HELDOUBLECHECKED
 
778
      COMMON/INIT/CHECKPHASE, HELDOUBLECHECKED
 
779
 
 
780
      INTEGER HELOFFSET
 
781
      INTEGER GOODHEL(NCOMB)
 
782
      LOGICAL GOODAMP(NSQUAREDSO,NLOOPGROUPS)
 
783
      COMMON/FILTERS/GOODAMP,GOODHEL,HELOFFSET
 
784
 
 
785
      COMPLEX*16 LOOPRES(3,NSQUAREDSO,NLOOPGROUPS)
 
786
      LOGICAL S(NSQUAREDSO,NLOOPGROUPS)
 
787
      COMMON/LOOPRES/LOOPRES,S
 
788
 
 
789
 
 
790
      COMPLEX*16 W(20,NWAVEFUNCS)
 
791
      COMMON/W/W
 
792
      COMPLEX*32 MP_W(20,NWAVEFUNCS)
 
793
      COMMON/MP_W/MP_W
 
794
 
 
795
      REAL*8 LSCALE
 
796
      INTEGER CTMODE
 
797
      COMMON/CT/LSCALE,CTMODE
 
798
      INTEGER LIBINDEX
 
799
      COMMON/I_LIB/LIBINDEX
 
800
 
 
801
C     ----------
 
802
C     BEGIN CODE
 
803
C     ----------
 
804
 
 
805
C     Determine it uses qp or not
 
806
      DOING_QP = (CTMODE.GE.4)
 
807
 
 
808
      IF (CHECKPHASE.OR.(.NOT.HELDOUBLECHECKED)
 
809
     $ .OR.GOODAMP(SQUAREDSOINDEX,LOOPNUM)) THEN
 
810
        WE(1)=W1
 
811
        WE(2)=W2
 
812
        WE(3)=W3
 
813
        M2L(1)=M3**2
 
814
        M2L(2)=M1**2
 
815
        M2L(3)=M2**2
 
816
        DO I=1,NLOOPLINE
 
817
          PAIRING(I)=1
 
818
        ENDDO
 
819
 
 
820
        R=RANK
 
821
        ID=LOOPNUM
 
822
        SQSOINDEX=SQUAREDSOINDEX
 
823
        DO I=0,3
 
824
          TEMP=1
 
825
          DO J=1,NLOOPLINE
 
826
            PL(I,J)=0.D0
 
827
            IF (DOING_QP) THEN
 
828
              MP_PL(I,J)=0.0E+0_16
 
829
            ENDIF
 
830
            DO K=TEMP,(TEMP+PAIRING(J)-1)
 
831
              PL(I,J)=PL(I,J)-DBLE(W(1+I,WE(K)))
 
832
              IF (DOING_QP) THEN
 
833
                MP_PL(I,J)=MP_PL(I,J)-REAL(MP_W(1+I,WE(K)),KIND=16)
 
834
              ENDIF
 
835
            ENDDO
 
836
            TEMP=TEMP+PAIRING(J)
 
837
          ENDDO
 
838
        ENDDO
 
839
C       Determine whether the integral is with complex masses or not
 
840
C       since some reduction libraries, e.g.PJFry++ and IREGI, are
 
841
C        still
 
842
C       not able to deal with complex masses
 
843
        COMPLEX_MASS=.FALSE.
 
844
        DO I=1,NLOOPLINE
 
845
          IF(DIMAG(M2L(I)).EQ.0D0)CYCLE
 
846
          IF(ABS(DIMAG(M2L(I)))/MAX(ABS(M2L(I)),1D-2).GT.1D-15)THEN
 
847
            COMPLEX_MASS=.TRUE.
 
848
            EXIT
 
849
          ENDIF
 
850
        ENDDO
 
851
C       Choose the correct loop library
 
852
        CALL CHOOSE_LOOPLIB(LIBINDEX,NLOOPLINE,RANK,COMPLEX_MASS,ID
 
853
     $   ,DOING_QP,I_LIB)
 
854
        IF(MLREDUCTIONLIB(I_LIB).EQ.1)THEN
 
855
C         CutTools is used
 
856
          CALL CTLOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1,SQUAREDSOINDEX
 
857
     $     ,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
 
858
        ELSEIF (MLREDUCTIONLIB(I_LIB).EQ.6) THEN
 
859
C         Ninja is used
 
860
          IF (.NOT.DOING_QP) THEN
 
861
            CALL NINJA_LOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1
 
862
     $       ,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
 
863
          ELSE
 
864
            WRITE(*,*) 'ERROR: Ninja should not be called in quadruple'
 
865
     $       //' precision since the installed version considered does'
 
866
     $       //' not support it.'
 
867
            STOP 9
 
868
          ENDIF
 
869
        ELSE
 
870
C         Tensor Integral Reduction is used 
 
871
          CALL TIRLOOP(SQUAREDSOINDEX,LOOPNUM,I_LIB,NLOOPLINE,PL,M2L
 
872
     $     ,RANK,LOOPRES(1,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX
 
873
     $     ,LOOPNUM))
 
874
        ENDIF
 
875
      ELSE
 
876
        LOOPRES(1,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
 
877
        LOOPRES(2,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
 
878
        LOOPRES(3,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
 
879
        S(SQUAREDSOINDEX,LOOPNUM)=.TRUE.
 
880
      ENDIF
 
881
      END
 
882
 
596
883
      SUBROUTINE LOOP_4(W1, W2, W3, W4, M1, M2, M3, M4,  RANK,
597
884
     $  SQUAREDSOINDEX, LOOPNUM)
598
885
      INTEGER    NEXTERNAL
879
1166
      ENDIF
880
1167
      END
881
1168
 
882
 
      SUBROUTINE LOOP_3(W1, W2, W3, M1, M2, M3,  RANK, SQUAREDSOINDEX,
883
 
     $  LOOPNUM)
884
 
      INTEGER    NEXTERNAL
885
 
      PARAMETER (NEXTERNAL=4)
886
 
      INTEGER    NLOOPLINE
887
 
      PARAMETER (NLOOPLINE=3)
888
 
      INTEGER    NWAVEFUNCS
889
 
      PARAMETER (NWAVEFUNCS=6)
890
 
      INTEGER    NLOOPGROUPS
891
 
      PARAMETER (NLOOPGROUPS=25)
892
 
      INTEGER    NCOMB
893
 
      PARAMETER (NCOMB=16)
894
 
C     These are constants related to the split orders
895
 
      INTEGER    NSQUAREDSO
896
 
      PARAMETER (NSQUAREDSO=1)
897
 
C     
898
 
C     ARGUMENTS 
899
 
C     
900
 
      INTEGER W1, W2, W3
901
 
      COMPLEX*16 M1, M2, M3
902
 
 
903
 
      INTEGER RANK, LSYMFACT
904
 
      INTEGER LOOPNUM, SQUAREDSOINDEX
905
 
C     
906
 
C     LOCAL VARIABLES 
907
 
C     
908
 
      REAL*8 PL(0:3,NLOOPLINE)
909
 
      REAL*16 MP_PL(0:3,NLOOPLINE)
910
 
      COMPLEX*16 M2L(NLOOPLINE)
911
 
      INTEGER PAIRING(NLOOPLINE),WE(3)
912
 
      INTEGER I, J, K, TEMP,I_LIB
913
 
      LOGICAL COMPLEX_MASS,DOING_QP
914
 
C     
915
 
C     GLOBAL VARIABLES
916
 
C     
917
 
      INCLUDE 'MadLoopParams.inc'
918
 
      INTEGER ID,SQSOINDEX,R
919
 
      COMMON/LOOP/ID,SQSOINDEX,R
920
 
 
921
 
      LOGICAL CHECKPHASE, HELDOUBLECHECKED
922
 
      COMMON/INIT/CHECKPHASE, HELDOUBLECHECKED
923
 
 
924
 
      INTEGER HELOFFSET
925
 
      INTEGER GOODHEL(NCOMB)
926
 
      LOGICAL GOODAMP(NSQUAREDSO,NLOOPGROUPS)
927
 
      COMMON/FILTERS/GOODAMP,GOODHEL,HELOFFSET
928
 
 
929
 
      COMPLEX*16 LOOPRES(3,NSQUAREDSO,NLOOPGROUPS)
930
 
      LOGICAL S(NSQUAREDSO,NLOOPGROUPS)
931
 
      COMMON/LOOPRES/LOOPRES,S
932
 
 
933
 
 
934
 
      COMPLEX*16 W(20,NWAVEFUNCS)
935
 
      COMMON/W/W
936
 
      COMPLEX*32 MP_W(20,NWAVEFUNCS)
937
 
      COMMON/MP_W/MP_W
938
 
 
939
 
      REAL*8 LSCALE
940
 
      INTEGER CTMODE
941
 
      COMMON/CT/LSCALE,CTMODE
942
 
      INTEGER LIBINDEX
943
 
      COMMON/I_LIB/LIBINDEX
944
 
 
945
 
C     ----------
946
 
C     BEGIN CODE
947
 
C     ----------
948
 
 
949
 
C     Determine it uses qp or not
950
 
      DOING_QP = (CTMODE.GE.4)
951
 
 
952
 
      IF (CHECKPHASE.OR.(.NOT.HELDOUBLECHECKED)
953
 
     $ .OR.GOODAMP(SQUAREDSOINDEX,LOOPNUM)) THEN
954
 
        WE(1)=W1
955
 
        WE(2)=W2
956
 
        WE(3)=W3
957
 
        M2L(1)=M3**2
958
 
        M2L(2)=M1**2
959
 
        M2L(3)=M2**2
960
 
        DO I=1,NLOOPLINE
961
 
          PAIRING(I)=1
962
 
        ENDDO
963
 
 
964
 
        R=RANK
965
 
        ID=LOOPNUM
966
 
        SQSOINDEX=SQUAREDSOINDEX
967
 
        DO I=0,3
968
 
          TEMP=1
969
 
          DO J=1,NLOOPLINE
970
 
            PL(I,J)=0.D0
971
 
            IF (DOING_QP) THEN
972
 
              MP_PL(I,J)=0.0E+0_16
973
 
            ENDIF
974
 
            DO K=TEMP,(TEMP+PAIRING(J)-1)
975
 
              PL(I,J)=PL(I,J)-DBLE(W(1+I,WE(K)))
976
 
              IF (DOING_QP) THEN
977
 
                MP_PL(I,J)=MP_PL(I,J)-REAL(MP_W(1+I,WE(K)),KIND=16)
978
 
              ENDIF
979
 
            ENDDO
980
 
            TEMP=TEMP+PAIRING(J)
981
 
          ENDDO
982
 
        ENDDO
983
 
C       Determine whether the integral is with complex masses or not
984
 
C       since some reduction libraries, e.g.PJFry++ and IREGI, are
985
 
C        still
986
 
C       not able to deal with complex masses
987
 
        COMPLEX_MASS=.FALSE.
988
 
        DO I=1,NLOOPLINE
989
 
          IF(DIMAG(M2L(I)).EQ.0D0)CYCLE
990
 
          IF(ABS(DIMAG(M2L(I)))/MAX(ABS(M2L(I)),1D-2).GT.1D-15)THEN
991
 
            COMPLEX_MASS=.TRUE.
992
 
            EXIT
993
 
          ENDIF
994
 
        ENDDO
995
 
C       Choose the correct loop library
996
 
        CALL CHOOSE_LOOPLIB(LIBINDEX,NLOOPLINE,RANK,COMPLEX_MASS,ID
997
 
     $   ,DOING_QP,I_LIB)
998
 
        IF(MLREDUCTIONLIB(I_LIB).EQ.1)THEN
999
 
C         CutTools is used
1000
 
          CALL CTLOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1,SQUAREDSOINDEX
1001
 
     $     ,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
1002
 
        ELSEIF (MLREDUCTIONLIB(I_LIB).EQ.6) THEN
1003
 
C         Ninja is used
1004
 
          IF (.NOT.DOING_QP) THEN
1005
 
            CALL NINJA_LOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1
1006
 
     $       ,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
1007
 
          ELSE
1008
 
            WRITE(*,*) 'ERROR: Ninja should not be called in quadruple'
1009
 
     $       //' precision since the installed version considered does'
1010
 
     $       //' not support it.'
1011
 
            STOP 9
1012
 
          ENDIF
1013
 
        ELSE
1014
 
C         Tensor Integral Reduction is used 
1015
 
          CALL TIRLOOP(SQUAREDSOINDEX,LOOPNUM,I_LIB,NLOOPLINE,PL,M2L
1016
 
     $     ,RANK,LOOPRES(1,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX
1017
 
     $     ,LOOPNUM))
1018
 
        ENDIF
1019
 
      ELSE
1020
 
        LOOPRES(1,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
1021
 
        LOOPRES(2,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
1022
 
        LOOPRES(3,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
1023
 
        S(SQUAREDSOINDEX,LOOPNUM)=.TRUE.
1024
 
      ENDIF
1025
 
      END
1026
 
 
1027
 
      SUBROUTINE LOOP_2(W1, W2, M1, M2,  RANK, SQUAREDSOINDEX, LOOPNUM)
1028
 
      INTEGER    NEXTERNAL
1029
 
      PARAMETER (NEXTERNAL=4)
1030
 
      INTEGER    NLOOPLINE
1031
 
      PARAMETER (NLOOPLINE=2)
1032
 
      INTEGER    NWAVEFUNCS
1033
 
      PARAMETER (NWAVEFUNCS=6)
1034
 
      INTEGER    NLOOPGROUPS
1035
 
      PARAMETER (NLOOPGROUPS=25)
1036
 
      INTEGER    NCOMB
1037
 
      PARAMETER (NCOMB=16)
1038
 
C     These are constants related to the split orders
1039
 
      INTEGER    NSQUAREDSO
1040
 
      PARAMETER (NSQUAREDSO=1)
1041
 
C     
1042
 
C     ARGUMENTS 
1043
 
C     
1044
 
      INTEGER W1, W2
1045
 
      COMPLEX*16 M1, M2
1046
 
 
1047
 
      INTEGER RANK, LSYMFACT
1048
 
      INTEGER LOOPNUM, SQUAREDSOINDEX
1049
 
C     
1050
 
C     LOCAL VARIABLES 
1051
 
C     
1052
 
      REAL*8 PL(0:3,NLOOPLINE)
1053
 
      REAL*16 MP_PL(0:3,NLOOPLINE)
1054
 
      COMPLEX*16 M2L(NLOOPLINE)
1055
 
      INTEGER PAIRING(NLOOPLINE),WE(2)
1056
 
      INTEGER I, J, K, TEMP,I_LIB
1057
 
      LOGICAL COMPLEX_MASS,DOING_QP
1058
 
C     
1059
 
C     GLOBAL VARIABLES
1060
 
C     
1061
 
      INCLUDE 'MadLoopParams.inc'
1062
 
      INTEGER ID,SQSOINDEX,R
1063
 
      COMMON/LOOP/ID,SQSOINDEX,R
1064
 
 
1065
 
      LOGICAL CHECKPHASE, HELDOUBLECHECKED
1066
 
      COMMON/INIT/CHECKPHASE, HELDOUBLECHECKED
1067
 
 
1068
 
      INTEGER HELOFFSET
1069
 
      INTEGER GOODHEL(NCOMB)
1070
 
      LOGICAL GOODAMP(NSQUAREDSO,NLOOPGROUPS)
1071
 
      COMMON/FILTERS/GOODAMP,GOODHEL,HELOFFSET
1072
 
 
1073
 
      COMPLEX*16 LOOPRES(3,NSQUAREDSO,NLOOPGROUPS)
1074
 
      LOGICAL S(NSQUAREDSO,NLOOPGROUPS)
1075
 
      COMMON/LOOPRES/LOOPRES,S
1076
 
 
1077
 
 
1078
 
      COMPLEX*16 W(20,NWAVEFUNCS)
1079
 
      COMMON/W/W
1080
 
      COMPLEX*32 MP_W(20,NWAVEFUNCS)
1081
 
      COMMON/MP_W/MP_W
1082
 
 
1083
 
      REAL*8 LSCALE
1084
 
      INTEGER CTMODE
1085
 
      COMMON/CT/LSCALE,CTMODE
1086
 
      INTEGER LIBINDEX
1087
 
      COMMON/I_LIB/LIBINDEX
1088
 
 
1089
 
C     ----------
1090
 
C     BEGIN CODE
1091
 
C     ----------
1092
 
 
1093
 
C     Determine it uses qp or not
1094
 
      DOING_QP = (CTMODE.GE.4)
1095
 
 
1096
 
      IF (CHECKPHASE.OR.(.NOT.HELDOUBLECHECKED)
1097
 
     $ .OR.GOODAMP(SQUAREDSOINDEX,LOOPNUM)) THEN
1098
 
        WE(1)=W1
1099
 
        WE(2)=W2
1100
 
        M2L(1)=M2**2
1101
 
        M2L(2)=M1**2
1102
 
        DO I=1,NLOOPLINE
1103
 
          PAIRING(I)=1
1104
 
        ENDDO
1105
 
 
1106
 
        R=RANK
1107
 
        ID=LOOPNUM
1108
 
        SQSOINDEX=SQUAREDSOINDEX
1109
 
        DO I=0,3
1110
 
          TEMP=1
1111
 
          DO J=1,NLOOPLINE
1112
 
            PL(I,J)=0.D0
1113
 
            IF (DOING_QP) THEN
1114
 
              MP_PL(I,J)=0.0E+0_16
1115
 
            ENDIF
1116
 
            DO K=TEMP,(TEMP+PAIRING(J)-1)
1117
 
              PL(I,J)=PL(I,J)-DBLE(W(1+I,WE(K)))
1118
 
              IF (DOING_QP) THEN
1119
 
                MP_PL(I,J)=MP_PL(I,J)-REAL(MP_W(1+I,WE(K)),KIND=16)
1120
 
              ENDIF
1121
 
            ENDDO
1122
 
            TEMP=TEMP+PAIRING(J)
1123
 
          ENDDO
1124
 
        ENDDO
1125
 
C       Determine whether the integral is with complex masses or not
1126
 
C       since some reduction libraries, e.g.PJFry++ and IREGI, are
1127
 
C        still
1128
 
C       not able to deal with complex masses
1129
 
        COMPLEX_MASS=.FALSE.
1130
 
        DO I=1,NLOOPLINE
1131
 
          IF(DIMAG(M2L(I)).EQ.0D0)CYCLE
1132
 
          IF(ABS(DIMAG(M2L(I)))/MAX(ABS(M2L(I)),1D-2).GT.1D-15)THEN
1133
 
            COMPLEX_MASS=.TRUE.
1134
 
            EXIT
1135
 
          ENDIF
1136
 
        ENDDO
1137
 
C       Choose the correct loop library
1138
 
        CALL CHOOSE_LOOPLIB(LIBINDEX,NLOOPLINE,RANK,COMPLEX_MASS,ID
1139
 
     $   ,DOING_QP,I_LIB)
1140
 
        IF(MLREDUCTIONLIB(I_LIB).EQ.1)THEN
1141
 
C         CutTools is used
1142
 
          CALL CTLOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1,SQUAREDSOINDEX
1143
 
     $     ,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
1144
 
        ELSEIF (MLREDUCTIONLIB(I_LIB).EQ.6) THEN
1145
 
C         Ninja is used
1146
 
          IF (.NOT.DOING_QP) THEN
1147
 
            CALL NINJA_LOOP(NLOOPLINE,PL,M2L,RANK,LOOPRES(1
1148
 
     $       ,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX,LOOPNUM))
1149
 
          ELSE
1150
 
            WRITE(*,*) 'ERROR: Ninja should not be called in quadruple'
1151
 
     $       //' precision since the installed version considered does'
1152
 
     $       //' not support it.'
1153
 
            STOP 9
1154
 
          ENDIF
1155
 
        ELSE
1156
 
C         Tensor Integral Reduction is used 
1157
 
          CALL TIRLOOP(SQUAREDSOINDEX,LOOPNUM,I_LIB,NLOOPLINE,PL,M2L
1158
 
     $     ,RANK,LOOPRES(1,SQUAREDSOINDEX,LOOPNUM),S(SQUAREDSOINDEX
1159
 
     $     ,LOOPNUM))
1160
 
        ENDIF
1161
 
      ELSE
1162
 
        LOOPRES(1,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
1163
 
        LOOPRES(2,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
1164
 
        LOOPRES(3,SQUAREDSOINDEX,LOOPNUM)=(0.0D0,0.0D0)
1165
 
        S(SQUAREDSOINDEX,LOOPNUM)=.TRUE.
1166
 
      ENDIF
1167
 
      END
1168