BOSS 7.0.3
BESIII Offline Software System
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Friends | List of all members
Minor5 Class Reference

#include <minor.h>

+ Inheritance diagram for Minor5:

Public Types

typedef SPtr< Minor5 > Ptr
 

Public Member Functions

ncomplex evalE (int ep)
 
ncomplex evalE (int ep, int i)
 
ncomplex evalE (int ep, int i, int j)
 
ncomplex evalE (int ep, int i, int j, int k)
 
ncomplex evalE (int ep, int i, int j, int k, int l)
 
ncomplex evalE (int ep, int i, int j, int k, int l, int m)
 
ncomplex I4s (int ep, int s)
 
ncomplex I3st (int ep, int s, int t)
 
ncomplex I4Ds (int ep, int s)
 
ncomplex I4Dsi (int ep, int s, int i)
 
ncomplex I2stu (int ep, int s, int t, int u)
 
ncomplex I3Dst (int ep, int s, int t)
 
ncomplex I4D2s (int ep, int s)
 
ncomplex I4D2si (int ep, int s, int i)
 
ncomplex I3Dsti (int ep, int s, int t, int i)
 
ncomplex I3D2st (int ep, int s, int t)
 
ncomplex I4D3s (int ep, int s)
 
ncomplex I4D2sij (int ep, int s, int i, int j)
 
ncomplex I2Dstu (int ep, int s, int t, int u)
 
ncomplex I3D2sti (int ep, int s, int t, int i)
 
ncomplex I4D3si (int ep, int s, int i)
 
ncomplex I4D3sij (int ep, int s, int i, int j)
 
ncomplex I2Dstui (int ep, int s, int t, int u, int i)
 
ncomplex I3D2stij (int ep, int s, int t, int i, int j)
 
ncomplex I4D3sijk (int ep, int s, int i, int j, int k)
 
ncomplex I4D4s (int ep, int s)
 
ncomplex I4D4si (int ep, int s, int i)
 
ncomplex I3D3sti (int ep, int s, int t, int i)
 
ncomplex I4D4sij (int ep, int s, int i, int j)
 
ncomplex I2D2stui (int ep, int s, int t, int u, int i)
 
ncomplex I3D3stij (int ep, int s, int t, int i, int j)
 
ncomplex I4D4sijk (int ep, int s, int i, int j, int k)
 
ncomplex I2D2stuij (int ep, int s, int t, int u, int i, int j)
 
ncomplex I3D3stijk (int ep, int s, int t, int i, int j, int k)
 
ncomplex I4D4sijkl (int ep, int s, int i, int j, int k, int l)
 
ncomplex I2D2stu (int ep, int s, int t, int u)
 
ncomplex I3D3st (int ep, int s, int t)
 
ncomplex I2D3stu (int ep, int s, int t, int u)
 
ncomplex I3D4st (int ep, int s, int t)
 
ncomplex I2D4stu (int ep, int s, int t, int u)
 
ncomplex I3D5st (int ep, int s, int t)
 
ncomplex I2D5stu (int ep, int s, int t, int u)
 
ncomplex I3D6st (int ep, int s, int t)
 
ncomplex I2D6stu (int ep, int s, int t, int u)
 
ncomplex I3D7st (int ep, int s, int t)
 
double M1 (int i, int l) PURE
 
double M2 (int i, int j, int l, int m) PURE
 
double M3 (int i, int j, int k, int l, int m, int n) PURE
 
double gram3 (double p1, double p2, double p3) PURE
 
- Public Member Functions inherited from Minor< 5 >
 Minor ()
 
double Kay (int i, int j) PURE
 
- Public Member Functions inherited from MinorBase
 MinorBase ()
 
- Public Member Functions inherited from SRefCnt
 SRefCnt ()
 

Static Public Member Functions

static Ptr create (const Kinem5 &k)
 
static Ptr create (const Kinem4 &k)
 
- Static Public Member Functions inherited from MinorBase
static int ns (int i, int j) CONST
 
static int nss (int i, int j) CONST
 
static int is (int i, int j) CONST
 
static int is (int i, int j, int k) CONST
 
static int is (int i, int j, int k, int l) CONST
 
static int iss (int i, int j) CONST
 
static int iss (int i, int j, int k) CONST
 
static int iss (int i, int j, int k, int l) CONST
 
static int iss (int i, int j, int k, int l, int m) CONST
 
static double getmeps ()
 
static int im3 (int i, int j, int k) CONST
 
static int im2 (int i, int j) CONST
 
static int signM3ud (int i, int j, int k, int l, int m, int n) CONST
 
static int signM2ud (int i, int j, int l, int m) CONST
 
static void freeidxM3 (int set[], int free[])
 
static void Rescale (double factor)
 

Friends

class SPtr< Minor5 >
 

Additional Inherited Members

- Protected Attributes inherited from Minor< 5 >
double Cay [(DCay-1) *(DCay)/2]
 
- Protected Attributes inherited from SRefCnt
int count
 
- Static Protected Attributes inherited from Minor< 5 >
static const int DCay
 
- Static Protected Attributes inherited from MinorBase
static const unsigned char idxtbl [64]
 
static const double teps =1e-14
 
static const double heps =1e-15
 
static const double ceps =5e-2
 
static const double deps1 =5e-2
 
static const double deps2 =5e-2
 
static const double deps3 =5e-2
 
static const double seps1 =1e-8
 
static const double seps2 =1e-5
 
static const double epsir1 =5e-6
 
static const double epsir2 =5e-6
 
static double deps =1e-14
 
static double meps =1e-10
 
static double m3eps =1
 

Detailed Description

Definition at line 214 of file minor.h.

Member Typedef Documentation

◆ Ptr

typedef SPtr<Minor5> Minor5::Ptr

Definition at line 218 of file minor.h.

Member Function Documentation

◆ create() [1/2]

static Ptr Minor5::create ( const Kinem4 &  k)
inlinestatic

Definition at line 220 of file minor.h.

220{ return Ptr(new Minor5(k)); }
Minor5
Definition: minor.h:215
Minor5::Ptr
SPtr< Minor5 > Ptr
Definition: minor.h:218

◆ create() [2/2]

static Ptr Minor5::create ( const Kinem5 &  k)
inlinestatic

Definition at line 219 of file minor.h.

219{ return Ptr(new Minor5(k)); }

Referenced by getMinorN().

◆ evalE() [1/6]

ncomplex Minor5::evalE ( int  ep)

Definition at line 24 of file minoreval.cpp.

25{
26 ncomplex ivalue=0;
27 ncomplex sum1=0;
28 const double d00=M1(0, 0);
29 for (int s=1; s<=5; s++) {
30 sum1+=M1(0, s)*I4s(ep, s);
31 }
32 ivalue=sum1/d00;
33 return ivalue;
34}
s
XmlRpcServer s
Definition: HelloServer.cpp:11
Minor5::I4s
ncomplex I4s(int ep, int s)
Definition: minor.cpp:809
Minor5::M1
double M1(int i, int l) PURE
Definition: minor.cpp:462
ncomplex
std::complex< double > ncomplex
Definition: common.h:25

◆ evalE() [2/6]

ncomplex Minor5::evalE ( int  ep,
int  i 
)

Definition at line 40 of file minoreval.cpp.

41{
42 ncomplex ivalue=0;
43 ncomplex sum1=0;
44 const double d00=M1(0, 0);
45 for (int s=1; s<=5; s++) {
46 sum1+=M2(0, i, 0, s)*I4s(ep, s);
47 }
48 ivalue=-sum1/d00;
49 return ivalue;
50}
Minor5::M2
double M2(int i, int j, int l, int m) PURE
Definition: minor.cpp:471

◆ evalE() [3/6]

ncomplex Minor5::evalE ( int  ep,
int  i,
int  j 
)

Definition at line 56 of file minoreval.cpp.

57{
58 ncomplex ivalue=0;
59 const double d00=M1(0, 0);
60 if (i==0 && j==0) {
61 ncomplex sum1=0;
62 for (int s=1; s<=5; s++) {
63 sum1+=M1(0, s)*I4Ds(ep, s);
64 }
65 ivalue=-sum1/(2*d00);
66 }
67 else {
68 assert(i!=0 && j!=0); // E01, E02, etc do not exist
69 ncomplex sum1=0;
70 for (int s=1; s<=5; s++) {
71 sum1+=M2(0, i, s, j)*I4Ds(ep, s);
72 sum1+=M2(0, s, 0, j)*I4Dsi(ep, s, i);
73 }
74// if (i!=j) { // is symmetrization needed?
75// ncomplex sumX=0;
76// for (int s=1; s<=5; s++) {
77// sumX+=M2(0, j, s, i)*I4Ds(ep, s);
78// sumX+=M2(0, s, 0, i)*I4Dsi(ep, s, j);
79// }
80// sum1=0.5*(sum1+sumX);
81// }
82 ivalue=sum1/d00;
83 }
84 return ivalue;
85}
Minor5::I4Ds
ncomplex I4Ds(int ep, int s)
Definition: minor.cpp:956
Minor5::I4Dsi
ncomplex I4Dsi(int ep, int s, int i)
Definition: minor.cpp:1046

◆ evalE() [4/6]

ncomplex Minor5::evalE ( int  ep,
int  i,
int  j,
int  k 
)

Definition at line 91 of file minoreval.cpp.

92{
93 ncomplex ivalue=0;
94 const double d00=M1(0, 0);
95 if (i==0 && j==0) {
96 assert(i==0 && j==0 && k!=0); // E000 does not exist, E100 is a wrong syntax
97
98 /* // Fleischer's formula 6.13
99 ncomplex sum1=0;
100 for (int s=1; s<=5; s++) {
101 sum1+=0.5*M2(0, s, 0, k)*I4Ds(ep, s);
102 sum1+=-M1(s, k)*I4D2s(ep, s); // (4-1)/3=1 // NB d-1=3 and d=4
103 }
104 ivalue=sum1/d00;
105 */
106 // This variant looks simpler (does not depend on I4D2s)
107 ncomplex sum1=0;
108 for (int s=1; s<=5; s++) {
109 sum1+=0.5*M2(0, s, 0, k)*I4Ds(ep, s);
110 sum1+=M1(s, 0)*I4D2si(ep, s, k);
111 }
112 ivalue=sum1/(3*d00);
113 }
114 else {
115 assert(i!=0 && j!=0 && k!=0); // E110, E012, etc do not exist
116 ncomplex sum1=0;
117 ncomplex sumX=0;
118 ncomplex sumY=0;
119 if (i == j) {
120 for (int s=1; s<=5; s++) {
121 sum1+=2*M2(0, j, s, k)*I4D2si(ep, s, i);
122 sum1+=M2(0, s, 0, k)*I4D2sij(ep, s, i, j);
123 }
124 if (i != k) {
125 for (int s=1; s<=5; s++) {
126 sumX+=M2(0, j, s, i)*I4D2si(ep, s, k);
127 sumX+=M2(0, k, s, i)*I4D2si(ep, s, j);
128 sumX+=M2(0, s, 0, i)*I4D2sij(ep, s, k, j);
129 }
130 sum1=(sum1+2.*sumX)/3.;
131 }
132 } else { // i!=j
133 for (int s=1; s<=5; s++) {
134 sum1+=M2(0, j, s, k)*I4D2si(ep, s, i);
135 sum1+=M2(0, i, s, k)*I4D2si(ep, s, j);
136 sum1+=M2(0, s, 0, k)*I4D2sij(ep, s, i, j);
137 }
138 if (i != k) {
139 for (int s=1; s<=5; s++) {
140 sumX+=M2(0, j, s, i)*I4D2si(ep, s, k);
141 sumX+=M2(0, k, s, i)*I4D2si(ep, s, j);
142 sumX+=M2(0, s, 0, i)*I4D2sij(ep, s, k, j);
143 }
144 }
145 else { sumX=sum1; }
146 if (j != k) {
147 for (int s=1; s<=5; s++) {
148 sumY+=M2(0, k, s, j)*I4D2si(ep, s, i);
149 sumY+=M2(0, i, s, j)*I4D2si(ep, s, k);
150 sumY+=M2(0, s, 0, j)*I4D2sij(ep, s, i, k);
151 }
152 }
153 else { sumY=sum1; }
154 sum1=(sum1+sumX+sumY)/3.;
155 }
156 ivalue=-sum1/d00;
157 }
158 return ivalue;
159}
Minor5::I4D2si
ncomplex I4D2si(int ep, int s, int i)
Definition: minor.cpp:1302
Minor5::I4D2sij
ncomplex I4D2sij(int ep, int s, int i, int j)
Definition: minor.cpp:1460

◆ evalE() [5/6]

ncomplex Minor5::evalE ( int  ep,
int  i,
int  j,
int  k,
int  l 
)

Definition at line 165 of file minoreval.cpp.

166{
167 ncomplex ivalue=0;
168 const double d00=M1(0, 0);
169
170 if (i==0 && j==0) {
171 if (k==0 && l==0) {
172 ncomplex sum1=0;
173 for (int s=1; s<=5; s++) {
174#ifndef USE_GOLEM_MODE
175// Cancel pole and finite part with E00ij - LoopTools-like convention
176 sum1+=M1(s, 0)*(I4D2s(ep, s)+(ep==0 ? (-1./6.+1./4.) : (ep==1? -1./6.: 0.)));
177#else
178// Golem95 convention
179 sum1+=M1(s, 0)*(I4D2s(ep, s)+(ep==0 ? -1./9. : 0.));
180#endif
181 }
182 ivalue=0.25*sum1/d00;
183 }
184 else {
185 assert(i==0 && j==0 && k!=0 && l!=0); // E0001 does not exist, E1200 is a wrong syntax
186 ncomplex sum1=0;
187
188 for (int s=1; s<=5; s++) {
189#ifndef USE_GOLEM_MODE
190// Cancel pole and finite part with E0000 - LoopTools-like convention
191 sum1+=0.5*(M2(0, k, s, l)+M2(0, l, s, k))*(I4D2s(ep, s)+(ep==0 ? (-1./6.+1./4.) : (ep==1? -1./6.: 0.)));
192#else
193// Golem95 convention
194 sum1+=0.5*(M2(0, k, s, l)+M2(0, l, s, k))*(I4D2s(ep, s)+(ep==0 ? -1./9. : 0.));
195#endif
196 sum1+=0.5*(M2(0, s, 0, l)*I4D2si(ep, s, k)+M2(0, s, 0, k)*I4D2si(ep, s, l));
197 sum1+=0.5*M1(s, 0)*(I4D3sij(ep, s, k, l)+I4D3sij(ep, s, l, k));
198 }
199 ivalue=-0.25*sum1/d00;
200 }
201 }
202 else {
203 assert(i!=0 && j!=0 && k!=0 && l!=0); // E110, E012, etc do not exist
204 ncomplex sum1234=0;
205 for (int s=1; s<=5; s++) {
206 ncomplex sum1=M2(0,k,s,l)*I4D3sij(ep,s,i,j)
207 +M2(0,i,s,l)*I4D3sij(ep,s,k,j)
208 +M2(0,j,s,l)*I4D3sij(ep,s,i,k)
209 +M2(0,s,0,l)*I4D3sijk(ep,s,i,j,k);
210 ncomplex sum2=sum1;
211 if (l!=k) {
212 sum2=M2(0,l,s,k)*I4D3sij(ep,s,i,j)
213 +M2(0,i,s,k)*I4D3sij(ep,s,l,j)
214 +M2(0,j,s,k)*I4D3sij(ep,s,i,l)
215 +M2(0,s,0,k)*I4D3sijk(ep,s,i,j,l);
216 }
217 ncomplex sum3=sum1;
218 if (j==k) {
219 sum3=sum2;
220 }
221 else if (l!=j) {
222 sum3=M2(0,k,s,j)*I4D3sij(ep,s,i,l)
223 +M2(0,i,s,j)*I4D3sij(ep,s,k,l)
224 +M2(0,l,s,j)*I4D3sij(ep,s,i,k)
225 +M2(0,s,0,j)*I4D3sijk(ep,s,i,l,k);
226 }
227 ncomplex sum4=sum1;
228 if (i==j) {
229 sum4=sum3;
230 }
231 else if (l!=i) {
232 sum4=M2(0,k,s,i)*I4D3sij(ep,s,l,j)
233 +M2(0,l,s,i)*I4D3sij(ep,s,k,j)
234 +M2(0,j,s,i)*I4D3sij(ep,s,l,k)
235 +M2(0,s,0,i)*I4D3sijk(ep,s,l,j,k);
236 }
237 sum1234+=sum1+sum2+sum3+sum4;
238 }
239 ivalue=sum1234/(4*d00);
240 }
241 return ivalue;
242}
Minor5::I4D3sijk
ncomplex I4D3sijk(int ep, int s, int i, int j, int k)
Definition: minor.cpp:2180
Minor5::I4D3sij
ncomplex I4D3sij(int ep, int s, int i, int j)
Definition: minor.cpp:1952
Minor5::I4D2s
ncomplex I4D2s(int ep, int s)
Definition: minor.cpp:1208

◆ evalE() [6/6]

ncomplex Minor5::evalE ( int  ep,
int  i,
int  j,
int  k,
int  l,
int  m 
)

Definition at line 248 of file minoreval.cpp.

249{
250 ncomplex ivalue=0;
251 const double d00=M1(0, 0);
252
253 if (i==0 && j==0) {
254 if (k==0 && l==0) {
255 assert(m!=0); // E00000 does not exist
256 ncomplex sum1=0;
257 for (int s=1; s<=5; s++) {
258 sum1+=+M2(0, s, 0, m)*I4D2s(ep, s)
259 +M1(s, 0)*(4.*I4D3si(ep, s, m)-2.*(ep<2 ? I4D3si(ep+1, s, m) : 0.));
260 }
261 ivalue=-sum1/(20.*d00);
262 }
263 else {
264 assert(i==0 && j==0 && k!=0 && l!=0 && m!=0); // E00012 does not exist, E00100 is a wrong syntax
265 ncomplex sum1=0;
266 ncomplex sumX=0;
267 ncomplex sumY=0;
268 if (k == l) {
269 for (int s=1; s<=5; s++) {
270 sum1+=+2*M2(0, k, s, m)*I4D3si(ep, s, l)
271 +M2(0, s, 0, m)*I4D3sij(ep, s, k, l);
272 }
273 if (ep==0) sum1+=1./24.*(M1(k, m)-M2(0, k, l, m));
274 if (k != m) {
275 for (int s=1; s<=5; s++) {
276 sumX+=+M2(0, m, s, k)*I4D3si(ep, s, l)
277 +M2(0, l, s, k)*I4D3si(ep, s, m)
278 +M2(0, s, 0, k)*I4D3sij(ep, s, m, l);
279 }
280 if (ep==0) sumX+=1./48.*(M1(m, k)+M1(l, k)-M2(0, l, m, k));
281 sum1=(sum1+2.*sumX)/3.;
282 }
283 } else { // k!=l
284 for (int s=1; s<=5; s++) {
285 sum1+=+M2(0, k, s, m)*I4D3si(ep, s, l)
286 +M2(0, l, s, m)*I4D3si(ep, s, k)
287 +M2(0, s, 0, m)*I4D3sij(ep, s, k, l);
288 }
289 if (ep==0) sum1+=1./48.*(M1(k, m)+M1(l, m)-M2(0, k, l, m)-M2(0, l, k, m));
290 if (k != m) {
291 for (int s=1; s<=5; s++) {
292 sumX+=+M2(0, m, s, k)*I4D3si(ep, s, l)
293 +M2(0, l, s, k)*I4D3si(ep, s, m)
294 +M2(0, s, 0, k)*I4D3sij(ep, s, m, l);
295 }
296 if (ep==0) sumX+=1./48.*(M1(m, k)+M1(l, k)-M2(0, m, l, k)-M2(0, l, m, k));
297 }
298 else { sumX=sum1; }
299 if (l != m) {
300 for (int s=1; s<=5; s++) {
301 sumY+=+M2(0, k, s, l)*I4D3si(ep, s, m)
302 +M2(0, m, s, l)*I4D3si(ep, s, k)
303 +M2(0, s, 0, l)*I4D3sij(ep, s, k, m);
304 }
305 if (ep==0) sumY+=1./48.*(M1(k, l)+M1(m, l)-M2(0, k, m, l)-M2(0, m, k, l));
306 }
307 else { sumY=sum1; }
308 sum1=(sum1+sumX+sumY)/3.;
309 }
310 sumX=0;
311 for (int s=1; s<=5; s++) {
312 sumX+=M1(s,0)*I4D4sijk(ep, s, k, l, m);
313 }
314 sum1=3.*sum1+2.*sumX;
315 ivalue=sum1/(10.*d00);
316 }
317 }
318 else {
319 assert(i!=0 && j!=0 && k!=0 && l!=0 && m!=0);
320 ncomplex sum12345=0;
321 for (int s=1; s<=5; s++) {
322 ncomplex sum1=+M2(0, l, s, m)*I4D4sijk(ep, s, i, j, k)
323 +M2(0, i, s, m)*I4D4sijk(ep, s, l, j, k)
324 +M2(0, j, s, m)*I4D4sijk(ep, s, i, l, k)
325 +M2(0, k, s, m)*I4D4sijk(ep, s, i, j, l)
326 +M2(0, s, 0, m)*I4D4sijkl(ep, s, i, j, k, l);
327 ncomplex sum2=sum1;
328 if (m!=l) {
329 sum2=+M2(0, m, s, l)*I4D4sijk(ep, s, i, j, k)
330 +M2(0, i, s, l)*I4D4sijk(ep, s, m, j, k)
331 +M2(0, j, s, l)*I4D4sijk(ep, s, i, m, k)
332 +M2(0, k, s, l)*I4D4sijk(ep, s, i, j, m)
333 +M2(0, s, 0, l)*I4D4sijkl(ep, s, i, j, k, m);
334 }
335 ncomplex sum3=sum1;
336 if (k==l) {
337 sum3=sum2;
338 }
339 else if (m!=k) {
340 sum3=+M2(0, l, s, k)*I4D4sijk(ep, s, i, j, m)
341 +M2(0, i, s, k)*I4D4sijk(ep, s, l, j, m)
342 +M2(0, j, s, k)*I4D4sijk(ep, s, i, l, m)
343 +M2(0, m, s, k)*I4D4sijk(ep, s, i, j, l)
344 +M2(0, s, 0, k)*I4D4sijkl(ep, s, i, j, m, l);
345 }
346 ncomplex sum4=sum1;
347 if (j==k) {
348 sum4=sum3;
349 }
350 else if (m!=j) {
351 sum4=+M2(0, l, s, j)*I4D4sijk(ep, s, i, m, k)
352 +M2(0, i, s, j)*I4D4sijk(ep, s, l, m, k)
353 +M2(0, m, s, j)*I4D4sijk(ep, s, i, l, k)
354 +M2(0, k, s, j)*I4D4sijk(ep, s, i, m, l)
355 +M2(0, s, 0, j)*I4D4sijkl(ep, s, i, m, k, l);
356 }
357 ncomplex sum5=sum1;
358 if (i==j) {
359 sum5=sum4;
360 }
361 else if (m!=i) {
362 sum5=+M2(0, l, s, i)*I4D4sijk(ep, s, m, j, k)
363 +M2(0, m, s, i)*I4D4sijk(ep, s, l, j, k)
364 +M2(0, j, s, i)*I4D4sijk(ep, s, m, l, k)
365 +M2(0, k, s, i)*I4D4sijk(ep, s, m, j, l)
366 +M2(0, s, 0, i)*I4D4sijkl(ep, s, m, j, k, l);
367 }
368 sum12345+=sum1+sum2+sum3+sum4+sum5;
369 }
370 ivalue=-sum12345/(5*d00);
371 }
372 return ivalue;
373}
Minor5::I4D4sijk
ncomplex I4D4sijk(int ep, int s, int i, int j, int k)
Definition: minor.cpp:3003
Minor5::I4D3si
ncomplex I4D3si(int ep, int s, int i)
Definition: minor.cpp:1907
Minor5::I4D4sijkl
ncomplex I4D4sijkl(int ep, int s, int i, int j, int k, int l)
Definition: minor.cpp:3275

◆ gram3()

double Minor5::gram3 ( double  p1,
double  p2,
double  p3 
)

Definition at line 546 of file minor.cpp.

547{
548 double g3;
549 if (fabs(p1) > fabs(p2)) {
550 if (fabs(p1) > fabs(p3)) {
551 const double diff=(p1 - p2 - p3);
552 const double subs=(-4.)*p2*p3;
553 g3=diff*diff+subs;
554 }
555 else {
556 const double diff=(p3 - p2 - p1);
557 const double subs=(-4.)*p2*p1;
558 g3=diff*diff+subs;
559 }
560 }
561 else {
562 if (fabs(p2) > fabs(p3)) {
563 const double diff=(p2 - p1 - p3);
564 const double subs=(-4.)*p1*p3;
565 g3=diff*diff+subs;
566 }
567 else {
568 const double diff=(p3 - p2 - p1);
569 const double subs=(-4.)*p2*p1;
570 g3=diff*diff+subs;
571 }
572 }
573 return g3;
574}

◆ I2D2stu()

ncomplex Minor5::I2D2stu ( int  ep,
int  s,
int  t,
int  u 
)

Definition at line 2242 of file minor.cpp.

2243{
2244 assert(t!=u && u!=s && s!=t);
2245 if (ep==2) return 0;
2246 if (not fEval[E_I2D2stu+ep]) {
2247 I2D2stuEval(0,ep,1,2,3,4,5,kinem.p5());
2248 I2D2stuEval(1,ep,1,2,4,3,5,kinem.s45());
2249 I2D2stuEval(2,ep,1,2,5,3,4,kinem.p4());
2250
2251 I2D2stuEval(3,ep,1,3,4,2,5,kinem.s12());
2252 I2D2stuEval(4,ep,1,3,5,2,4,kinem.s34());
2253
2254 I2D2stuEval(5,ep,1,4,5,2,3,kinem.p3());
2255
2256 if (smax==5) {
2257 I2D2stuEval(6,ep,2,3,4,1,5,kinem.p1());
2258 I2D2stuEval(7,ep,2,3,5,1,4,kinem.s15());
2259
2260 I2D2stuEval(8,ep,2,4,5,1,3,kinem.s23());
2261
2262
2263 I2D2stuEval(9,ep,3,4,5,1,2,kinem.p2());
2264 }
2265
2266 fEval[E_I2D2stu+ep]=true;
2267 }
2268 int idx=im3(s,t,u)-10;
2269 return pI2D2stu[ep][idx];
2270}
Kinem5::p4
double p4() const
Definition: kinem.h:207
Kinem5::p3
double p3() const
Definition: kinem.h:206
Kinem5::p1
double p1() const
Definition: kinem.h:204
Kinem5::s15
double s15() const
Definition: kinem.h:218
Kinem5::s45
double s45() const
Definition: kinem.h:217
Kinem5::p2
double p2() const
Definition: kinem.h:205
Kinem5::p5
double p5() const
Definition: kinem.h:208
Kinem5::s34
double s34() const
Definition: kinem.h:216
Kinem5::s12
double s12() const
Definition: kinem.h:214
Kinem5::s23
double s23() const
Definition: kinem.h:215
MinorBase::im3
static int im3(int i, int j, int k) CONST
Definition: minor.h:613
t
int t()
Definition: t.c:1

◆ I2D2stui()

ncomplex Minor5::I2D2stui ( int  ep,
int  s,
int  t,
int  u,
int  i 
)

Definition at line 2776 of file minor.cpp.

2777{
2778 assert(s!=t && t!=u && u!=s && s!=i && t!=i && u!=i);
2779 if (ep==2) return 0;
2780 if (not fEval[E_I2D2stui+ep]) {
2781 I2D2stuiEval(ep,1,4,5,2,3,kinem.p3());
2782 I2D2stuiEval(ep,1,3,5,2,4,kinem.s34());
2783 I2D2stuiEval(ep,1,3,4,2,5,kinem.s12());
2784 I2D2stuiEval(ep,1,4,5,3,2,kinem.p3());
2785 I2D2stuiEval(ep,1,2,5,3,4,kinem.p4());
2786 I2D2stuiEval(ep,1,2,4,3,5,kinem.s45());
2787 I2D2stuiEval(ep,1,3,5,4,2,kinem.s34());
2788 I2D2stuiEval(ep,1,2,5,4,3,kinem.p4());
2789 I2D2stuiEval(ep,1,2,3,4,5,kinem.p5());
2790#ifdef USE_ZERO_CHORD
2791 I2D2stuiEval(ep,1,3,4,5,2,kinem.s12());
2792 I2D2stuiEval(ep,1,2,4,5,3,kinem.s45());
2793 I2D2stuiEval(ep,1,2,3,5,4,kinem.p5());
2794#endif
2795
2796 if (smax==5) {
2797 I2D2stuiEval(ep,3,4,5,1,2,kinem.p2());
2798 I2D2stuiEval(ep,2,4,5,1,3,kinem.s23());
2799 I2D2stuiEval(ep,2,3,5,1,4,kinem.s15());
2800 I2D2stuiEval(ep,2,3,4,1,5,kinem.p1());
2801 I2D2stuiEval(ep,3,4,5,2,1,kinem.p2());
2802 I2D2stuiEval(ep,2,4,5,3,1,kinem.s23());
2803 I2D2stuiEval(ep,2,3,5,4,1,kinem.s15());
2804#ifdef USE_ZERO_CHORD
2805 I2D2stuiEval(ep,2,3,4,5,1,kinem.p1());
2806#endif
2807 }
2808
2809 fEval[E_I2D2stui+ep]=true;
2810 }
2811 int ip=15-s-t-u-i; // ip
2812 return pI2D2stui[ep][i-1][ip-1];
2813}

◆ I2D2stuij()

ncomplex Minor5::I2D2stuij ( int  ep,
int  s,
int  t,
int  u,
int  i,
int  j 
)

Definition at line 3056 of file minor.cpp.

3057{
3058 assert(s!=t && t!=u && u!=s && s!=i && t!=i && u!=i && s!=j && t!=j && u!=j);
3059 if (ep==2) return 0;
3060 if (not fEval[E_I2D2stuij+ep]) {
3061 I2D2stuijEval(ep,1,2,3,4,5,kinem.p5());
3062 I2D2stuijEval(ep,1,2,4,3,5,kinem.s45());
3063 I2D2stuijEval(ep,1,2,5,3,4,kinem.p4());
3064 I2D2stuijEval(ep,1,2,5,4,3,kinem.p4());
3065
3066 I2D2stuijEval(ep,1,3,4,2,5,kinem.s12());
3067 I2D2stuijEval(ep,1,3,5,2,4,kinem.s34());
3068 I2D2stuijEval(ep,1,3,5,4,2,kinem.s34());
3069
3070 I2D2stuijEval(ep,1,4,5,2,3,kinem.p3());
3071 I2D2stuijEval(ep,1,4,5,3,2,kinem.p3());
3072
3073#ifdef USE_ZERO_CHORD
3074 I2D2stuijEval(ep,1,2,3,5,4,kinem.p5());
3075 I2D2stuijEval(ep,1,2,4,5,3,kinem.s45());
3076 I2D2stuijEval(ep,1,3,4,5,2,kinem.s12());
3077#endif
3078 if (smax==5) {
3079 I2D2stuijEval(ep,2,3,4,1,5,kinem.p1());
3080 I2D2stuijEval(ep,2,3,5,1,4,kinem.s15());
3081 I2D2stuijEval(ep,2,3,5,4,1,kinem.s15());
3082 I2D2stuijEval(ep,2,4,5,1,3,kinem.s23());
3083 I2D2stuijEval(ep,2,4,5,3,1,kinem.s23());
3084 I2D2stuijEval(ep,3,4,5,1,2,kinem.p2());
3085 I2D2stuijEval(ep,3,4,5,2,1,kinem.p2());
3086#ifdef USE_ZERO_CHORD
3087 I2D2stuijEval(ep,2,3,4,5,1,kinem.p1());
3088#endif
3089 }
3090
3091 fEval[E_I2D2stuij+ep]=true;
3092 }
3093 int ip=15-s-t-u-i; // ip
3094 return pI2D2stuij[ep][i-1][ip-1][i==j ? 0 : 1];
3095}

◆ I2D3stu()

ncomplex Minor5::I2D3stu ( int  ep,
int  s,
int  t,
int  u 
)

Definition at line 142 of file minorex.cpp.

143{
144 assert(t!=u && u!=s && s!=t); //if (t==u || u==s || s==t) return 0;
145 if (ep==2) return 0;
146 if (not fEval[E_I2D3stu+ep]) {
147 I2D3stuEval(0,ep,1,2,3,4,5,kinem.p5());
148 I2D3stuEval(1,ep,1,2,4,3,5,kinem.s45());
149 I2D3stuEval(2,ep,1,2,5,3,4,kinem.p4());
150
151 I2D3stuEval(3,ep,1,3,4,2,5,kinem.s12());
152 I2D3stuEval(4,ep,1,3,5,2,4,kinem.s34());
153
154 I2D3stuEval(5,ep,1,4,5,2,3,kinem.p3());
155
156 if (smax==5) {
157 I2D3stuEval(6,ep,2,3,4,1,5,kinem.p1());
158 I2D3stuEval(7,ep,2,3,5,1,4,kinem.s15());
159
160 I2D3stuEval(8,ep,2,4,5,1,3,kinem.s23());
161
162
163 I2D3stuEval(9,ep,3,4,5,1,2,kinem.p2());
164 }
165
166 fEval[E_I2D3stu+ep]=true;
167 }
168 int idx=im3(s,t,u)-10;
169 return pI2D3stu[ep][idx];
170}

◆ I2D4stu()

ncomplex Minor5::I2D4stu ( int  ep,
int  s,
int  t,
int  u 
)

Definition at line 275 of file minorex.cpp.

276{
277 assert(t!=u && u!=s && s!=t); //if (t==u || u==s || s==t) return 0;
278 if (ep==2) return 0;
279 if (not fEval[E_I2D4stu+ep]) {
280 I2D4stuEval(0,ep,1,2,3,4,5,kinem.p5());
281 I2D4stuEval(1,ep,1,2,4,3,5,kinem.s45());
282 I2D4stuEval(2,ep,1,2,5,3,4,kinem.p4());
283
284 I2D4stuEval(3,ep,1,3,4,2,5,kinem.s12());
285 I2D4stuEval(4,ep,1,3,5,2,4,kinem.s34());
286
287 I2D4stuEval(5,ep,1,4,5,2,3,kinem.p3());
288
289 if (smax==5) {
290 I2D4stuEval(6,ep,2,3,4,1,5,kinem.p1());
291 I2D4stuEval(7,ep,2,3,5,1,4,kinem.s15());
292
293 I2D4stuEval(8,ep,2,4,5,1,3,kinem.s23());
294
295
296 I2D4stuEval(9,ep,3,4,5,1,2,kinem.p2());
297 }
298
299 fEval[E_I2D4stu+ep]=true;
300 }
301 int idx=im3(s,t,u)-10;
302 return pI2D4stu[ep][idx];
303}

◆ I2D5stu()

ncomplex Minor5::I2D5stu ( int  ep,
int  s,
int  t,
int  u 
)

Definition at line 412 of file minorex.cpp.

413{
414 assert(t!=u && u!=s && s!=t); //if (t==u || u==s || s==t) return 0;
415 if (ep==2) return 0;
416 if (not fEval[E_I2D5stu+ep]) {
417 I2D5stuEval(0,ep,1,2,3,4,5,kinem.p5());
418 I2D5stuEval(1,ep,1,2,4,3,5,kinem.s45());
419 I2D5stuEval(2,ep,1,2,5,3,4,kinem.p4());
420
421 I2D5stuEval(3,ep,1,3,4,2,5,kinem.s12());
422 I2D5stuEval(4,ep,1,3,5,2,4,kinem.s34());
423
424 I2D5stuEval(5,ep,1,4,5,2,3,kinem.p3());
425
426 if (smax==5) {
427 I2D5stuEval(6,ep,2,3,4,1,5,kinem.p1());
428 I2D5stuEval(7,ep,2,3,5,1,4,kinem.s15());
429
430 I2D5stuEval(8,ep,2,4,5,1,3,kinem.s23());
431
432
433 I2D5stuEval(9,ep,3,4,5,1,2,kinem.p2());
434 }
435
436 fEval[E_I2D5stu+ep]=true;
437 }
438 int idx=im3(s,t,u)-10;
439 return pI2D5stu[ep][idx];
440}

◆ I2D6stu()

ncomplex Minor5::I2D6stu ( int  ep,
int  s,
int  t,
int  u 
)

Definition at line 547 of file minorex.cpp.

548{
549 assert(t!=u && u!=s && s!=t); //if (t==u || u==s || s==t) return 0;
550 if (ep==2) return 0;
551 if (not fEval[E_I2D6stu+ep]) {
552 I2D6stuEval(0,ep,1,2,3,4,5,kinem.p5());
553 I2D6stuEval(1,ep,1,2,4,3,5,kinem.s45());
554 I2D6stuEval(2,ep,1,2,5,3,4,kinem.p4());
555
556 I2D6stuEval(3,ep,1,3,4,2,5,kinem.s12());
557 I2D6stuEval(4,ep,1,3,5,2,4,kinem.s34());
558
559 I2D6stuEval(5,ep,1,4,5,2,3,kinem.p3());
560
561 if (smax==5) {
562 I2D6stuEval(6,ep,2,3,4,1,5,kinem.p1());
563 I2D6stuEval(7,ep,2,3,5,1,4,kinem.s15());
564
565 I2D6stuEval(8,ep,2,4,5,1,3,kinem.s23());
566
567
568 I2D6stuEval(9,ep,3,4,5,1,2,kinem.p2());
569 }
570
571 fEval[E_I2D6stu+ep]=true;
572 }
573 int idx=im3(s,t,u)-10;
574 return pI2D6stu[ep][idx];
575}

◆ I2Dstu()

ncomplex Minor5::I2Dstu ( int  ep,
int  s,
int  t,
int  u 
)

Definition at line 1514 of file minor.cpp.

1515{
1516 assert(t!=u && u!=s && s!=t);
1517 if (ep==2) return 0;
1518 if (not fEval[E_I2Dstu+ep]) {
1519 I2DstuEval(0,ep,1,2,3,4,5,kinem.p5());
1520 I2DstuEval(1,ep,1,2,4,3,5,kinem.s45());
1521 I2DstuEval(2,ep,1,2,5,3,4,kinem.p4());
1522
1523 I2DstuEval(3,ep,1,3,4,2,5,kinem.s12());
1524 I2DstuEval(4,ep,1,3,5,2,4,kinem.s34());
1525
1526 I2DstuEval(5,ep,1,4,5,2,3,kinem.p3());
1527
1528 if (smax==5) {
1529 I2DstuEval(6,ep,2,3,4,1,5,kinem.p1());
1530 I2DstuEval(7,ep,2,3,5,1,4,kinem.s15());
1531
1532 I2DstuEval(8,ep,2,4,5,1,3,kinem.s23());
1533
1534
1535 I2DstuEval(9,ep,3,4,5,1,2,kinem.p2());
1536 }
1537
1538 fEval[E_I2Dstu+ep]=true;
1539 }
1540 int idx=im3(s,t,u)-10;
1541 return pI2Dstu[ep][idx];
1542}

◆ I2Dstui()

ncomplex Minor5::I2Dstui ( int  ep,
int  s,
int  t,
int  u,
int  i 
)

Definition at line 2001 of file minor.cpp.

2002{
2003 assert(s!=t && t!=u && u!=s && s!=i && t!=i && u!=i);
2004// if (ep==1) return -0.5; // not quite true
2005 if (ep==2) return 0;
2006 if (not fEval[E_I2Dstui+ep]) {
2007 I2DstuiEval(ep,1,4,5,2,3,kinem.p3());
2008 I2DstuiEval(ep,1,3,5,2,4,kinem.s34());
2009 I2DstuiEval(ep,1,3,4,2,5,kinem.s12());
2010 I2DstuiEval(ep,1,4,5,3,2,kinem.p3());
2011 I2DstuiEval(ep,1,2,5,3,4,kinem.p4());
2012 I2DstuiEval(ep,1,2,4,3,5,kinem.s45());
2013 I2DstuiEval(ep,1,3,5,4,2,kinem.s34());
2014 I2DstuiEval(ep,1,2,5,4,3,kinem.p4());
2015 I2DstuiEval(ep,1,2,3,4,5,kinem.p5());
2016#ifdef USE_ZERO_CHORD
2017 I2DstuiEval(ep,1,3,4,5,2,kinem.s12());
2018 I2DstuiEval(ep,1,2,4,5,3,kinem.s45());
2019 I2DstuiEval(ep,1,2,3,5,4,kinem.p5());
2020#endif
2021
2022 if (smax==5) {
2023 I2DstuiEval(ep,3,4,5,1,2,kinem.p2());
2024 I2DstuiEval(ep,2,4,5,1,3,kinem.s23());
2025 I2DstuiEval(ep,2,3,5,1,4,kinem.s15());
2026 I2DstuiEval(ep,2,3,4,1,5,kinem.p1());
2027 I2DstuiEval(ep,3,4,5,2,1,kinem.p2());
2028 I2DstuiEval(ep,2,4,5,3,1,kinem.s23());
2029 I2DstuiEval(ep,2,3,5,4,1,kinem.s15());
2030#ifdef USE_ZERO_CHORD
2031 I2DstuiEval(ep,2,3,4,5,1,kinem.p1());
2032#endif
2033 }
2034
2035 fEval[E_I2Dstui+ep]=true;
2036 }
2037 int ip=15-s-t-u-i;
2038 return pI2Dstui[ep][i-1][ip-1];
2039}

◆ I2stu()

ncomplex Minor5::I2stu ( int  ep,
int  s,
int  t,
int  u 
)

Definition at line 898 of file minor.cpp.

899{
900 assert(t!=u && u!=s && s!=t);
901 if (ep>=2) return 0;
902
903 if (not fEval[E_I2stu+ep]) {
904 I2stuEval(ep);
905 }
906 int idx=im3(s,t,u)-10;
907 return pI2stu[ep][idx];
908}

◆ I3D2st()

ncomplex Minor5::I3D2st ( int  ep,
int  s,
int  t 
)

Definition at line 1593 of file minor.cpp.

1594{
1595 assert(s!=t);
1596 if (ep==2) return 0;
1597 if (not fEval[E_I3D2st+ep]) {
1598 I3D2stEval(ep);
1599 }
1600 int idx = im2(s,t)-5;
1601 return pI3D2st[ep][idx];
1602}
MinorBase::im2
static int im2(int i, int j) CONST
Definition: minor.h:620

◆ I3D2sti()

ncomplex Minor5::I3D2sti ( int  ep,
int  s,
int  t,
int  i 
)

Definition at line 1810 of file minor.cpp.

1811{
1812 assert(s!=t && s!=i && t!=i);
1813 if (ep==1) return 1./6.;
1814 else if (ep==2) return 0.;
1815 if (not fEval[E_I3D2sti+ep]) {
1816 I3D2stiEval(ep);
1817 }
1818 int idx = im2(s,t)-5;
1819 return pI3D2sti[ep][i-1][idx];
1820}

◆ I3D2stij()

ncomplex Minor5::I3D2stij ( int  ep,
int  s,
int  t,
int  i,
int  j 
)

Definition at line 2090 of file minor.cpp.

2091{
2092 assert(s!=t && s!=i && s!=j && t!=i && t!=j);
2093 if (not fEval[E_I3D2stij+ep]) {
2094 I3D2stijEval(ep);
2095 }
2096 int idx = im2(s,t)-5;
2097 return pI3D2stij[ep][is(i-1,j-1)][idx];
2098}
MinorBase::is
static int is(int i, int j) CONST
Definition: minor.h:85

◆ I3D3st()

ncomplex Minor5::I3D3st ( int  ep,
int  s,
int  t 
)

Definition at line 2323 of file minor.cpp.

2324{
2325 assert(s!=t);
2326 if (ep==2) return 0;
2327 if (not fEval[E_I3D3st+ep]) {
2328 I3D3stEval(ep);
2329 }
2330 int idx = im2(s,t)-5;
2331 return pI3D3st[ep][idx];
2332}

◆ I3D3sti()

ncomplex Minor5::I3D3sti ( int  ep,
int  s,
int  t,
int  i 
)

Definition at line 2618 of file minor.cpp.

2619{
2620 assert(s!=t && s!=i && t!=i);
2621 if (ep==2) return 0.;
2622 if (not fEval[E_I3D3sti+ep]) {
2623 I3D3stiEval(ep);
2624 }
2625 int idx = im2(s,t)-5;
2626 return pI3D3sti[ep][i-1][idx];
2627}

◆ I3D3stij()

ncomplex Minor5::I3D3stij ( int  ep,
int  s,
int  t,
int  i,
int  j 
)

Definition at line 2861 of file minor.cpp.

2862{
2863 assert(s!=t && s!=i && s!=j && t!=i && t!=j);
2864 if (ep==1) return ( i==j ? -1./12. : -1./24. ); // -1/12 == -2/24
2865 else if (ep==2) return 0;
2866 if (not fEval[E_I3D3stij+ep]) {
2867 I3D3stijEval(ep);
2868 }
2869 int idx = im2(s,t)-5;
2870 return pI3D3stij[ep][is(i-1,j-1)][idx];
2871}

◆ I3D3stijk()

ncomplex Minor5::I3D3stijk ( int  ep,
int  s,
int  t,
int  i,
int  j,
int  k 
)

Definition at line 3166 of file minor.cpp.

3167{
3168 assert(s!=t && s!=i && s!=j && s!=k && t!=i && t!=j && t!=k);
3169 if (not fEval[E_I3D3stijk+ep]) {
3170 I3D3stijkEval(ep);
3171 }
3172 int idx = im2(s,t)-5;
3173 return pI3D3stijk[ep][is(i-1,j-1,k-1)][idx];
3174}

◆ I3D4st()

ncomplex Minor5::I3D4st ( int  ep,
int  s,
int  t 
)

Definition at line 227 of file minorex.cpp.

228{
229 assert(s!=t); //if (s==t) return 0;
230 if (ep==2) return 0;
231 if (not fEval[E_I3D4st+ep]) {
232 I3D4stEval(ep);
233 }
234 int idx = im2(s,t)-5;
235 return pI3D4st[ep][idx];
236}

◆ I3D5st()

ncomplex Minor5::I3D5st ( int  ep,
int  s,
int  t 
)

Definition at line 365 of file minorex.cpp.

366{
367 assert(s!=t); //if (s==t) return 0;
368 if (ep==2) return 0;
369 if (not fEval[E_I3D5st+ep]) {
370 I3D5stEval(ep);
371 }
372 int idx = im2(s,t)-5;
373 return pI3D5st[ep][idx];
374}

◆ I3D6st()

ncomplex Minor5::I3D6st ( int  ep,
int  s,
int  t 
)

Definition at line 500 of file minorex.cpp.

501{
502 assert(s!=t); //if (s==t) return 0;
503 if (ep==2) return 0;
504 if (not fEval[E_I3D6st+ep]) {
505 I3D6stEval(ep);
506 }
507 int idx = im2(s,t)-5;
508 return pI3D6st[ep][idx];
509}

◆ I3D7st()

ncomplex Minor5::I3D7st ( int  ep,
int  s,
int  t 
)

Definition at line 636 of file minorex.cpp.

637{
638 assert(s!=t); //if (s==t) return 0;
639 if (ep==2) return 0;
640 if (not fEval[E_I3D7st+ep]) {
641 I3D7stEval(ep);
642 }
643 int idx = im2(s,t)-5;
644 return pI3D7st[ep][idx];
645}

◆ I3Dst()

ncomplex Minor5::I3Dst ( int  ep,
int  s,
int  t 
)

Definition at line 1096 of file minor.cpp.

1097{
1098 assert(s!=t);
1099 if (ep==1) return -0.5;
1100 else if (ep==2) return 0;
1101 if (not fEval[E_I3Dst+ep]) {
1102 I3DstEval(ep);
1103 }
1104 int idx = im2(s,t)-5;
1105 return pI3Dst[ep][idx];
1106}

◆ I3Dsti()

ncomplex Minor5::I3Dsti ( int  ep,
int  s,
int  t,
int  i 
)

Definition at line 1357 of file minor.cpp.

1358{
1359 assert(s!=t && s!=i && t!=i);
1360 if (not fEval[E_I3Dsti+ep]) {
1361 I3DstiEval(ep);
1362 }
1363 int idx = im2(s,t)-5;
1364 return pI3Dsti[ep][i-1][idx];
1365}

◆ I3st()

ncomplex Minor5::I3st ( int  ep,
int  s,
int  t 
)

Definition at line 849 of file minor.cpp.

850{
851 assert(s!=t);
852 if (not fEval[E_I3st+ep]) {
853 I3stEval(ep);
854 }
855 int idx = im2(s,t)-5;
856 return pI3st[ep][idx];
857}

◆ I4D2s()

ncomplex Minor5::I4D2s ( int  ep,
int  s 
)

Definition at line 1208 of file minor.cpp.

1209{
1210 if (ep==1) return 1./6.;
1211 else if (ep==2) return 0;
1212 if (not fEval[E_I4D2s+ep]) {
1213 I4D2sEval(ep);
1214 }
1215 return pI4D2s[ep][s-1];
1216}

Referenced by evalE().

◆ I4D2si()

ncomplex Minor5::I4D2si ( int  ep,
int  s,
int  i 
)

Definition at line 1302 of file minor.cpp.

1303{
1304 if (s==i) return 0;
1305 if (ep!=0) return 0; // I4D2si is finite
1306 if (not fEval[E_I4D2si+ep]) {
1307 I4D2siEval(ep);
1308 }
1309 return pI4D2si[ep][i-1][s-1];
1310}

Referenced by evalE().

◆ I4D2sij()

ncomplex Minor5::I4D2sij ( int  ep,
int  s,
int  i,
int  j 
)

Definition at line 1460 of file minor.cpp.

1461{
1462 if (s==i || s==j) return 0;
1463 if (not fEval[E_I4D2sij+ep]) {
1464 I4D2sijEval(ep);
1465 }
1466 return pI4D2sij[ep][is(i-1,j-1)][s-1];
1467}

Referenced by evalE().

◆ I4D3s()

ncomplex Minor5::I4D3s ( int  ep,
int  s 
)

Definition at line 1712 of file minor.cpp.

1713{
1714 if (ep==2) return 0;
1715 if (not fEval[E_I4D3s+ep]) {
1716 I4D3sEval(ep);
1717 }
1718 return pI4D3s[ep][s-1];
1719}

◆ I4D3si()

ncomplex Minor5::I4D3si ( int  ep,
int  s,
int  i 
)

Definition at line 1907 of file minor.cpp.

1908{
1909 if (s==i) return 0;
1910 if (ep==1) return -1./24.;
1911 else if (ep==2) return 0;
1912 if (not fEval[E_I4D3si+ep]) {
1913 I4D3siEval(ep);
1914 }
1915 return pI4D3si[ep][i-1][s-1];
1916}

Referenced by evalE().

◆ I4D3sij()

ncomplex Minor5::I4D3sij ( int  ep,
int  s,
int  i,
int  j 
)

Definition at line 1952 of file minor.cpp.

1953{
1954 if (s==i || s==j) return 0;
1955 else if (ep!=0) return 0; // I4D3sij is finite
1956 if (not fEval[E_I4D3sij+ep]) {
1957 I4D3sijEval(ep);
1958 }
1959 return pI4D3sij[ep][is(i-1,j-1)][s-1];
1960}

Referenced by evalE().

◆ I4D3sijk()

ncomplex Minor5::I4D3sijk ( int  ep,
int  s,
int  i,
int  j,
int  k 
)

Definition at line 2180 of file minor.cpp.

2181{
2182 if (s==i || s==j || s==k) return 0;
2183 if (not fEval[E_I4D3sijk+ep]) {
2184 I4D3sijkEval(ep);
2185 }
2186 return pI4D3sijk[ep][is(i-1,j-1,k-1)][s-1];
2187}

Referenced by evalE().

◆ I4D4s()

ncomplex Minor5::I4D4s ( int  ep,
int  s 
)

Definition at line 2452 of file minor.cpp.

2453{
2454 if (ep==2) return 0;
2455 if (not fEval[E_I4D4s+ep]) {
2456 I4D4sEval(ep);
2457 }
2458 return pI4D4s[ep][s-1];
2459}

◆ I4D4si()

ncomplex Minor5::I4D4si ( int  ep,
int  s,
int  i 
)

Definition at line 2559 of file minor.cpp.

2560{
2561 if (s==i) return 0;
2562 if (ep==2) return 0;
2563 if (not fEval[E_I4D4si+ep]) {
2564 I4D4siEval(ep);
2565 }
2566 return pI4D4si[ep][i-1][s-1];
2567}

◆ I4D4sij()

ncomplex Minor5::I4D4sij ( int  ep,
int  s,
int  i,
int  j 
)

Definition at line 2726 of file minor.cpp.

2727{
2728 if (s==i || s==j) return 0;
2729 if (ep==1) return ( i==j ? 1./60. : 1./120. );
2730 else if (ep==2) return 0;
2731 if (not fEval[E_I4D4sij+ep]) {
2732 I4D4sijEval(ep);
2733 }
2734 return pI4D4sij[ep][is(i-1,j-1)][s-1];
2735}

◆ I4D4sijk()

ncomplex Minor5::I4D4sijk ( int  ep,
int  s,
int  i,
int  j,
int  k 
)

Definition at line 3003 of file minor.cpp.

3004{
3005 if (s==i || s==j || s==k) return 0;
3006 if (ep==2) return 0; // I4D4sijk finite
3007 if (not fEval[E_I4D4sijk+ep]) {
3008 I4D4sijkEval(ep);
3009 }
3010 return pI4D4sijk[ep][is(i-1,j-1,k-1)][s-1];
3011}

Referenced by evalE().

◆ I4D4sijkl()

ncomplex Minor5::I4D4sijkl ( int  ep,
int  s,
int  i,
int  j,
int  k,
int  l 
)

Definition at line 3275 of file minor.cpp.

3276{
3277 if (s==i || s==j || s==k || s==l) return 0;
3278 if (not fEval[E_I4D4sijkl+ep]) {
3279 I4D4sijklEval(ep);
3280 }
3281 return pI4D4sijkl[ep][is(i-1,j-1,k-1,l-1)][s-1];
3282}

Referenced by evalE().

◆ I4Ds()

ncomplex Minor5::I4Ds ( int  ep,
int  s 
)

Definition at line 956 of file minor.cpp.

957{
958 if (ep!=0) return 0; // I4Ds is finite
959 if (not fEval[E_I4Ds+ep]) {
960 I4DsEval(ep);
961 }
962 return pI4Ds[ep][s-1];
963}

Referenced by evalE().

◆ I4Dsi()

ncomplex Minor5::I4Dsi ( int  ep,
int  s,
int  i 
)

Definition at line 1046 of file minor.cpp.

1047{
1048 if (s==i) return 0;
1049 if (not fEval[E_I4Dsi+ep]) {
1050 I4DsiEval(ep);
1051 }
1052 return pI4Dsi[ep][i-1][s-1];
1053}

Referenced by evalE().

◆ I4s()

ncomplex Minor5::I4s ( int  ep,
int  s 
)

Definition at line 809 of file minor.cpp.

810{
811 if (not fEval[E_I4s+ep]) {
812 I4sEval(ep);
813 }
814 return pI4s[ep][s-1];
815}

Referenced by evalE().

◆ M1()

double Minor5::M1 ( int  i,
int  l 
)

Definition at line 462 of file minor.cpp.

463{
464 return pM1[is(i,l)];
465}

Referenced by evalE().

◆ M2()

double Minor5::M2 ( int  i,
int  j,
int  l,
int  m 
)

Definition at line 471 of file minor.cpp.

472{
473 int sign=signM2ud(i,j,l,m);
474 if (sign==0) return 0;
475
476 int uidx=im2(i,j);
477 int lidx=im2(l,m);
478
479 return pM2[is(uidx,lidx)]*sign;
480}
MinorBase::signM2ud
static int signM2ud(int i, int j, int l, int m) CONST
Definition: minor.h:635

Referenced by evalE().

◆ M3()

double Minor5::M3 ( int  i,
int  j,
int  k,
int  l,
int  m,
int  n 
)

Definition at line 486 of file minor.cpp.

487{
488 int sign=signM3ud(i,j,k,l,m,n);
489 if (sign==0) return 0;
490
491 int uidx=im3(i,j,k);
492 int lidx=im3(l,m,n);
493
494 return pM3[is(uidx,lidx)]*sign;
495}
n
const Int_t n
Definition: DataBase/tau_mode.c:65
MinorBase::signM3ud
static int signM3ud(int i, int j, int k, int l, int m, int n) CONST
Definition: minor.h:627

Friends And Related Function Documentation

◆ SPtr< Minor5 >

friend class SPtr< Minor5 >
friend

Definition at line 211 of file minor.h.

The documentation for this class was generated from the following files: