← Back to branch summary

~chirality-flow/chiralityflow/ChiralityFlowMG

« back to all changes in this revision

Viewing changes to vendor/CutTools/src/qcdloop/ffca0.f

  • Committer: andrew.lifson at lu
  • Date: 2021-09-02 13:57:34 UTC
  • Revision ID: andrew.lifson@thep.lu.se-20210902135734-4eybgli0iljkax9b
added fresh copy of MG5_aMC_v3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
vendor/CutTools/src/qcdloop/ffca0.f
 
1
*###[ ffca0:
 
2
        subroutine ffca0(ca0,d0,xmm,cm,ier)
 
3
***#[*comment:***********************************************************
 
4
*                                                                       *
 
5
*       calculates the one-point function (see 't Hooft and             *
 
6
*       Veltman) for complex mass                                       *
 
7
*                                                                       *
 
8
*       Input:  d0      (real) infinity, result of the                  *
 
9
*                       renormalization procedure, the final            *
 
10
*                       answer should not depend on it.                 *
 
11
*               xmm     (real) arbitrary mass2, the final answer        *
 
12
*                       should not depend on this either.               *
 
13
*               cm      (complex) mass2, re>0, im<0.                    *
 
14
*                                                                       *
 
15
*       Output: ca0     (complex) A0, the one-point function,           *
 
16
*               ier     0 (OK)                                          *
 
17
*                                                                       *
 
18
*       Calls:  log.                                                    *
 
19
*                                                                       *
 
20
***#]*comment:***********************************************************
 
21
*  #[ declarations:
 
22
        implicit none
 
23
*
 
24
*       arguments
 
25
*
 
26
        integer ier
 
27
        DOUBLE COMPLEX ca0,cm
 
28
        DOUBLE PRECISION d0,xmm
 
29
*
 
30
*       local variables
 
31
*
 
32
        DOUBLE COMPLEX cmu,clogm,c
 
33
        DOUBLE PRECISION absc,xm
 
34
*
 
35
*       common blocks etc
 
36
*
 
37
        include 'ff.h'
 
38
        absc(c) = abs(DBLE(c)) + abs(DIMAG(c))
 
39
*
 
40
*  #] declarations:
 
41
*  #[ the real case:
 
42
*       
 
43
*       adapted to log-and-pole scheme 25-mar-1992
 
44
*       
 
45
        if ( DIMAG(cm) .eq. 0 .or. nschem .lt. 7 ) then
 
46
            xm = DBLE(cm)
 
47
            call ffxa0(ca0,d0,xmm,xm,ier)
 
48
            return
 
49
        endif
 
50
*  #] the real case:
 
51
*  #[ "calculations":
 
52
        if ( xmm .ne. 0 ) then
 
53
            cmu = cm/DBLE(xmm)
 
54
        else
 
55
            cmu = cm
 
56
        endif
 
57
        if ( absc(cmu) .gt. xclogm ) then
 
58
            clogm = log(cmu)
 
59
        else
 
60
            clogm = 0
 
61
            if ( cmu .ne. c0 ) call fferr(1,ier)
 
62
        endif
 
63
        ca0 = - cm * ( clogm - 1 - DBLE(d0) )
 
64
*  #] "calculations":
 
65
*  #[ debug:
 
66
        if (lwrite) then
 
67
            print *,'d0  = ',d0
 
68
            print *,'xmm = ',xmm
 
69
            print *,'cm  = ',cm
 
70
            print *,'ca0 = ',ca0
 
71
        endif
 
72
*  #] debug:
 
73
*###] ffca0:
 
74
        end
 
75
*###[ ffxa0:
 
76
        subroutine ffxa0(ca0,d0,xmm,xm,ier)
 
77
***#[*comment:***********************************************************
 
78
*                                                                       *
 
79
*       calculates the one-point function (see 't Hooft and             *
 
80
*       Veltman) for real mass                                          *
 
81
*                                                                       *
 
82
*       Input:  d0      (real) infinity, result of the                  *
 
83
*                       renormalization procedure, the final            *
 
84
*                       answer should not depend on it.                 *
 
85
*               xmm     (real) arbitrary mass2, the final answer        *
 
86
*                       should not depend on this either.               *
 
87
*               xm      (real) mass2,                                   *
 
88
*                                                                       *
 
89
*       Output: ca0     (complex) A0, the one-point function,           *
 
90
*               ier     0 (ok)                                          *
 
91
*                                                                       *
 
92
*       Calls:  log.                                                    *
 
93
*                                                                       *
 
94
***#]*comment:***********************************************************
 
95
*  #[ declarations:
 
96
        implicit none
 
97
*
 
98
*       arguments
 
99
*
 
100
        integer ier
 
101
        DOUBLE COMPLEX ca0
 
102
        DOUBLE PRECISION d0,xmm,xm
 
103
*
 
104
*       local variables
 
105
*
 
106
        DOUBLE PRECISION xmu,xlogm
 
107
*
 
108
*       common blocks etc
 
109
*
 
110
        
 
111
        include 'ff.h'
 
112
*  #] declarations:
 
113
*  #[ "calculations":
 
114
        if ( xmm .ne. 0 ) then
 
115
            xmu = xm/xmm
 
116
        else
 
117
            xmu = xm
 
118
        endif
 
119
        if ( xmu .gt. xalogm ) then
 
120
            xlogm = log(xmu)
 
121
        else
 
122
            xlogm = 0
 
123
            if ( xmu .ne. 0 ) call fferr(2,ier)
 
124
        endif
 
125
        ca0 = -(xm*(xlogm - 1 - d0))
 
126
*  #] "calculations":
 
127
*  #[ debug:
 
128
        if (lwrite) then
 
129
            print *,'d0  = ',d0
 
130
            print *,'xmm = ',xmm
 
131
            print *,'xm  = ',xm
 
132
            print *,'ca0 = ',ca0
 
133
        endif
 
134
*  #] debug:
 
135
*###] ffxa0:
 
136
        end
 
137
*###[ ffza0:
 
138
        subroutine ffza0(za0,d0,xmm,cm,xm,ndiv,ier)
 
139
***#[*comment:***********************************************************
 
140
*                                                                       *
 
141
*       calculates the one-point function (see 't Hooft and             *
 
142
*       Veltman) for complex mass in some on-shell scheme               *
 
143
*                                                                       *
 
144
*       Input:  d0      (real) infinity, result of the                  *
 
145
*                       renormalization procedure, the final            *
 
146
*                       answer should not depend on it.                 *
 
147
*               xmm     (real) arbitrary mass2, the final answer        *
 
148
*                       should not depend on this either.               *
 
149
*               cm      (complex) mass2, re>0, im<0.                    *
 
150
*               xm      (real) mass2, used instead of cm if onshel=true *
 
151
*               ndiv    (integer) if >0 return 0 (the number of         *
 
152
*                       divergences the A0 should contain)              *
 
153
*                                                                       *
 
154
*       Output: za0     (complex) A0, the one-point function,           *
 
155
*               ier     0 (OK)                                          *
 
156
*                                                                       *
 
157
*       Calls:  log.                                                    *
 
158
*                                                                       *
 
159
***#]*comment:***********************************************************
 
160
*  #[ declarations:
 
161
        implicit none
 
162
*
 
163
*       arguments
 
164
*
 
165
        integer ndiv,ier
 
166
        DOUBLE COMPLEX za0,cm
 
167
        DOUBLE PRECISION d0,xmm,xm
 
168
*
 
169
*       common blocks etc
 
170
*
 
171
        include 'ff.h'
 
172
*
 
173
*  #] declarations:
 
174
*  #[ preliminaries:
 
175
*
 
176
*       as the A0 cannot contain any on-shell singularities, return 
 
177
*       zero when one asks for one.
 
178
*
 
179
        if ( onshel .and. ndiv .gt. 0 ) then
 
180
            za0 = 0
 
181
            return
 
182
        endif
 
183
*
 
184
*  #] preliminaries:
 
185
*  #[ "work":
 
186
        if ( nschem.lt.7 ) then
 
187
            call ffxa0(za0,d0,xmm,xm,ier)
 
188
        else
 
189
            call ffca0(za0,d0,xmm,cm,ier)
 
190
        endif
 
191
*  #] "work":
 
192
*###] ffza0:
 
193
        end
 
194