def Sigma_decay(omega, k):
def integrand_cubic_1(ndim, xx, ncomp, ff, userdata):
q1, q2 = [xx[i] for i in range(ndim.contents.value)]
q = np.array([q1, q2])
kmq = k - q
omega_q = LSW.eigenvalue(q)
omega_kmq = LSW.eigenvalue(kmq)
gamma1 = vfun.cubic_gamma1(q, kmq, k)
integrand = 0.5 * (gamma1 * gamma1.conj()) / (
omega - omega_q - omega_kmq + 1j * cov_fact)
ff[0] = np.real(integrand)
ff[1] = np.imag(integrand)
return 0
print_header('Vegas')
res = pycuba.Vegas(integrand_cubic_1, 2, epsabs = 1e-3, \
verbose=2, ncomp=2, maxeval=1000000)
print_results('Vegas', res)
rres = res.get('results')
len_rres = len(rres)
iintegrals = np.zeros(len_rres)
for flag in range(len_rres):
iintegrals[flag] = rres[flag].get('integral')
return iintegrals
def Sigma_source(omega, k):
def integrand_cubic_2(ndim, xx, ncomp, ff, userdata):
q1, q2 = [xx[i] for i in range(ndim.contents.value)]
q = np.array([q1, q2])
mkmq = -k - q
omega_q = LSW.eigenvalue(q)
omega_mkmq = LSW.eigenvalue(mkmq)
gamma2 = vfun.cubic_gamma2(q, mkmq, k)
integrand = -0.5 * (gamma2 * gamma2.conj()) / (omega + omega_q +
omega_mkmq)
ff[0] = np.real(integrand)
ff[1] = np.imag(integrand)
return 0
print_header('Vegas')
res = pycuba.Vegas(integrand_cubic_2, 2, epsabs = 1e-3, \
verbose=2, ncomp=2, maxeval=100000)
print_results('Vegas', res)
rres = res.get('results')
len_rres = len(rres)
iintegrals = np.zeros(len_rres)
for flag in range(len_rres):
iintegrals[flag] = rres[flag].get('integral')
return iintegrals
def user_dat(aa):
def Integrand(ndim, xx, ncomp, ff, userdata):
x,y,z = [xx[i] for i in range(ndim.contents.value)]
result = aa*np.sin(x)*np.cos(y)*np.exp(z)
ff[0] = result
return 0
print_results('Vegas', pycuba.Vegas(Integrand, 3, verbose=2))
def N_bond():
print('---- start calculating the bond contrations N_ij')
def integrand_N(ndim, xx, comp, ff, userdata):
k1, k2, k3 = [xx[i] for i in range(ndim.contents.value)]
k = np.array([k1, k2, k3])
tmp, ubov = GLSW.eigensystem(k)
ubov11 = ubov[:2 * num_sub, :2 * num_sub]
ubov21 = ubov[2 * num_sub:, :2 * num_sub]
ubov11_c = ubov11.conj()
ubov21_c = ubov21.conj()
for bond in range(num_bond):
counter = 0
bond_vec = delta_ij[:, bond]
cphase = np.exp(-1j * 2.0 * np.pi * k @ bond_vec)
sub1 = sub_idx[bond, 0]
sub2 = sub_idx[bond, 1]
for flavor1 in range(2):
for flavor2 in range(2):
X1 = num_sub * flavor1 + sub1
X2 = num_sub * flavor2 + sub2
# N_onsite is pure real, imaginary part zero
N_ij = (ubov11[X1, :] * ubov11_c[X2, :] * cphase).sum()
ff[8 * bond + 2 * counter] = np.real(N_ij)
ff[8 * bond + 2 * counter + 1] = np.imag(N_ij)
counter += 1
return 0
NCOMP = num_bond * 8
print_header('Vegas')
res = pycuba.Vegas(integrand_N, NDIM, epsabs=1e-3, \
verbose=2, ncomp=NCOMP, maxeval=5000)
print_results('Vegas', res)
rres = res.get('results')
len_rres = len(rres)
iintegrals = np.zeros(len_rres)
for flag in range(len_rres):
iintegrals[flag] = rres[flag].get('integral')
return iintegrals
def barN_onsite():
print('---- start calculating the on-site contrations bar_N_ii ----')
def integrand_barN_onsite(ndim, xx, comp, ff, userdata):
k1, k2, k3 = [xx[i] for i in range(ndim.contents.value)]
k = np.array([k1, k2, k3])
tmp, ubov = GLSW.eigensystem(k)
ubov11 = ubov[:2 * num_sub, :2 * num_sub]
ubov21 = ubov[2 * num_sub:, :2 * num_sub]
ubov11_c = ubov11.conj()
ubov21_c = ubov21.conj()
for sub_lat in range(num_sub):
counter = 0
for flavor1 in range(2):
for flavor2 in range(2):
X1 = num_sub * flavor1 + sub_lat
X2 = num_sub * flavor2 + sub_lat
# integration of barN_onsite must be real, because
# it corresponds to local boson number reduction
barN_onsite = (ubov21[X1, :] * ubov21_c[X2, :]).sum()
ff[4 * sub_lat + counter] = np.real(barN_onsite)
counter += 1
return 0
print_header('Vegas')
res = pycuba.Vegas(integrand_barN_onsite, NDIM, epsabs=1e-3, \
verbose=2, ncomp=16, maxeval=5000)
print_results('Vegas', res)
rres = res.get('results')
len_rres = len(rres)
iintegrals = np.zeros(len_rres)
for flag in range(len_rres):
iintegrals[flag] = rres[flag].get('integral')
return iintegrals
def nornalizeBreitWigner(self, algo='vegas', nwidths=100):
def Integrand(ndim, xx, ncomp, ff, userdata):
a = self.MW - nwidths*self.GW
if a < 0.:
a = 0.0
b = self.MW + nwidths*self.GW
x = xx[0]*(b-a) + a
result = self.BreitWignerQ(x)
ff[0] = result*(b-a)
return 0
NDIM = 1
if algo=='chure':
res = pycuba.Cuhre(Integrand, NDIM, key=13, verbose=0)['results'][0]
elif algo=='vegas':
res = pycuba.Vegas(Integrand, NDIM , epsrel=0.0001, epsabs=1e-12, maxeval=1000000)['results'][0]
elif algo=='quad':
res = integrate.quad(self.BreitWignerQ, self.MW-nwidths*self.GW if self.MW-nwidths*self.GW>0. else 0.0, self.MW+nwidths*self.GW)[0]
self.normBW = res
def proceed_err(nidim, nods, nt):
r_vec = [nt, nidim]
p_integ = PyMikor()
fof = Integrand('FCN', nidim)
fof.normalize_a(2, 600)
exact_res = fof.exact_oscillatory()
v_integ = vegas.Integrator(nidim * [[0, 1]])
v_result = []
v_result.append(v_integ(fof.oscillatory_fcn, nitn=10, neval=1e3).mean)
v_result.append(v_integ(fof.oscillatory_fcn, nitn=10, neval=1e5).mean)
global ave, ucc
ave = fof.a
ucc = fof.u
def IntegCuba(ndim, xx, ncomp, ff, userdata):
# x, y, z = [xx[i] for i in range(ndim.contents.value)]
nnn = ndim.contents.value
sma = 0.
for i in range(nnn):
sma += ave[i] * xx[i]
ff[0] = math.cos(2. * math.pi * ucc[0] + sma)
# res = 1.
# for i in range(nnn):
# res *= 1./(1./math.pow(ave[i], 2) + math.pow(xx[i] - ucc[i], 2))
#ff[0] = res
return 0
NDIM = nidim
NCOMP = 1
NNEW = 1000
NMIN = 2
FLATNESS = 50.
KEY1 = 47
KEY2 = 1
KEY3 = 1
MAXPASS = 5
BORDER = 0.
MAXCHISQ = 10.
MINDEVIATION = .25
NGIVEN = 0
LDXGIVEN = NDIM
NEXTRA = 0
MINEVAL = 0
MAXEVAL = 50000
KEY = 0
def print_header(name):
print('-------------------- %s test -------------------' % name)
def print_results(name, results):
keys = ['nregions', 'neval', 'fail']
text = ["%s %d" % (k, results[k]) for k in keys if k in results]
print("%s RESULT:\t" % name.upper() + "\t".join(text))
for comp in results['results']:
print("%s RESULT:\t" % name.upper() +
"%(integral).8f +- %(error).8f\tp = %(prob).3f\n" % comp)
# print_header('Vegas')
vrs = pycuba.Vegas(IntegCuba, NDIM, verbose=0)
# print_results('Vegas', vrs)
v_result.append(vrs['results'][0]['integral'])
# print_header('Divonne')
cub = pycuba.Divonne(IntegCuba,
NDIM,
mineval=MINEVAL,
maxeval=MAXEVAL,
key1=KEY1,
key2=KEY2,
key3=KEY3,
maxpass=MAXPASS,
border=BORDER,
maxchisq=MAXCHISQ,
mindeviation=MINDEVIATION,
ldxgiven=LDXGIVEN,
verbose=0)
# print_results('Divonne', cub)
v_result.append(cub['results'][0]['integral'])
for v in v_result:
v = math.fabs((v - exact_res) / exact_res)
r_vec.append(format_num(v))
for tab_prime in nods:
p_integ.set_values(1, nidim, tab_prime, 1, sigma=2)
p_result = p_integ(fof.oscillatory_fcn) # , eps=1e-4
p_rel_res = math.fabs((p_result - exact_res) / exact_res)
r_vec.append(format_num(p_rel_res))
with open('data_oscillatory_a_norm1.csv', 'a', newline='') as file:
wr = csv.writer(file, delimiter=',', quoting=csv.QUOTE_ALL)
wr.writerow(r_vec)
del p_integ
def test_vegas():
print_header('Vegas')
print_results('Vegas', pycuba.Vegas(Integrand, NDIM, verbose=2))
def print_results(name, results):
keys = ['nregions', 'neval', 'fail']
text = ["%s %d" % (k, results[k]) for k in keys if k in results]
print("%s RESULT:\t" % name.upper() + "\t".join(text))
for comp in results['results']:
print("%s RESULT:\t" % name.upper() + \
"%(integral).8f +- %(error).8f\tp = %(prob).3f\n" % comp)
from os import environ as env
verbose = 2
if 'CUBAVERBOSE' in env:
verbose = int(env['CUBAVERBOSE'])
print_header('Vegas')
print_results('Vegas', pycuba.Vegas(Integrand, NDIM, verbose=2))
print_header('Suave')
print_results(
'Suave',
pycuba.Suave(Integrand, NDIM, NNEW, NMIN, FLATNESS, verbose=2 | 4))
print_header('Divonne')
print_results(
'Divonne',
pycuba.Divonne(Integrand,
NDIM,
mineval=MINEVAL,
maxeval=MAXEVAL,
key1=KEY1,
key2=KEY2,
def integrand_HF(ndim, xx, ncomp, ff, userdata):
q1, q2 = [xx[i] for i in range(ndim.contents.value)]
q = np.array([q1, q2])
k = np.zeros(2)
k[0], k[1] = cob.k12tokxy(q[0], q[1])
omegak = LSW.eigenvalue(q) / (3.0 * J_ex * spinsize)
gammak = LSW.gammak(k)
ff[0] = 1.0 / omegak
ff[1] = (gammak) / omegak
ff[2] = (gammak)**2 / omegak
return 0
res = pycuba.Vegas(integrand_HF, 2, epsabs = 1e-4, \
verbose=2, ncomp=3, maxeval=1000000)
print_results('Vegas', res)
rres = res.get('results')
len_rres = len(rres)
iintegrals = np.zeros(len_rres)
for flag in range(len_rres):
iintegrals[flag] = rres[flag].get('integral')
print(iintegrals)
fname = 'cintegrals.txt'
np.savetxt(fname, iintegrals)
print('-------------------- %s test -------------------' % name)
def print_results(name, results):
keys = ['nregions', 'neval', 'fail']
text = ["%s %d" % (k, results[k]) for k in keys if k in results]
print("%s RESULT:\t" % name.upper() + "\t".join(text))
for comp in results['results']:
print("%s RESULT:\t" % name.upper() + \
"%(integral).8f +- %(error).8f\tp = %(prob).3f\n" % comp)
from os import environ as env
verbose = 2
if 'CUBAVERBOSE' in env:
verbose = int(env['CUBAVERBOSE'])
print_header('Vegas')
RR = pycuba.Vegas(Integrand, NDIM, verbose=2)
print_results('Vegas', RR)
print_header('Suave')
print_results('Suave', pycuba.Suave(Integrand, NDIM, NNEW, NMIN, FLATNESS, verbose=2 | 4))
print_header('Divonne')
print_results('Divonne', pycuba.Divonne(Integrand, NDIM,
mineval=MINEVAL, maxeval=MAXEVAL,
key1=KEY1, key2=KEY2, key3=KEY3, maxpass=MAXPASS,
border=BORDER, maxchisq=MAXCHISQ, mindeviation=MINDEVIATION,
ldxgiven=LDXGIVEN, verbose=2))
print_header('Cuhre')
print_results('Cuhre', pycuba.Cuhre(Integrand, NDIM, key=KEY, verbose=2 | 4))
def run_cuba(**config):
NDIM = config['ndim']
loglikelihood = config['loglikelihood']
def Integrand(ndim, xx, ncomp, ff, userdata):
ff[0] = exp(loglikelihood([xx[i] for i in range(ndim.contents.value)]))
return 0
NCOMP = 1
NNEW = 1000
FLATNESS = 25.
KEY1 = 47
KEY2 = 1
KEY3 = 1
MAXPASS = 5
BORDER = 0.
MAXCHISQ = 10.
MINDEVIATION = .25
NGIVEN = 0
LDXGIVEN = NDIM
NEXTRA = 0
MINEVAL = 100
MAXEVAL = 2000000
epsrel=0.5
epsabs=1e-300
KEY = 0
commonargs = dict(
mineval=MINEVAL, maxeval=MAXEVAL,
epsrel=epsrel, epsabs=epsabs,
seed = config['seed'] + 1, # 0 stands for random
)
def print_results(name, results):
keys = ['nregions', 'neval', 'fail']
keys = list(filter(results.has_key, keys))
text = ["%s %d" % (k, results[k]) for k in keys]
print ("%s RESULT:\t" % name.upper() + "\t".join(text))
for comp in results['results']:
print ("%s RESULT:\t" % name.upper() + "%(integral).8f +- %(error).8f\tp = %(prob).3f\n" % comp)
starttime = time.time()
if config['cuba_algorithm'] == 'Vegas':
results = pycuba.Vegas(Integrand, NDIM, verbose=2, **commonargs)
elif config['cuba_algorithm'] == 'Suave':
results = pycuba.Suave(Integrand, NDIM, NNEW, FLATNESS, verbose=2 | 4, **commonargs)
elif config['cuba_algorithm'] == 'Divonne':
results = pycuba.Divonne(Integrand, NDIM,
key1=KEY1, key2=KEY2, key3=KEY3, maxpass=MAXPASS,
border=BORDER, maxchisq=MAXCHISQ, mindeviation=MINDEVIATION,
ldxgiven=LDXGIVEN, verbose=2, **commonargs)
elif config['cuba_algorithm'] == 'Cuhre':
results = pycuba.Cuhre(Integrand, NDIM, key=KEY, verbose=2 | 4, **commonargs)
else:
assert False, 'Unknown cuba algorithm "%s"!' % config['cuba_algorithm']
duration = time.time() - starttime
print_results(config['cuba_algorithm'], results)
Z = results['results'][0]['integral']
Zerr = results['results'][0]['error']
return dict(
Z_computed = float(log(abs(Z) + 1e-300)),
Z_computed_err = float(log(abs(Z+Zerr) + 1e-300) - log(abs(Z) + 1e-300)),
failed=results['fail'] != 0 and Z >= 0 and Zerr >= 0,
duration = duration,
)
def Sigma_decay(q, eq, ubov_q, ubov_mq):
"""
Calculates the decay self-energy using on-shell approximation
Parameters
----------
q : np.array((3, ))
incoming momentum.
eq : np.array((4*num_sub, ))
incoming energy.
ubov_q : np.array((4*num_sub, 4*num_sub))
Bogoliubov matrix of q.
ubov_mq : np.array((4*num_sub, 4*num_sub))
Bogoliubov matrix of -q.
Returns
-------
np.array((2*num_sub, ))
Self-energies for 2*num_sub bands.
"""
# define the integrand as a nested function
def integrand_decay(ndim, xx, ncopm, ff, userdata):
"""
Integrand passed to cuba.
Parameters
----------
ndim : int
dimension of integration.
xx : np.array((3, ))
input momentum.
ncopm : int
number of components.
ff : np.array()
integrand.
userdata : c-type
I don't know how to use this for python. try to avoid it
Returns
-------
int
value not relevent unless -999, see mannual.
"""
# integration variable: k
k1, k2, k3 = [xx[i] for i in range(ndim.contents.value)]
k = np.array([k1, k2, k3])
qmk = q - k
ek, ubov_k = GLSW.eigensystem(k)
eqmk, ubov_qmk = GLSW.eigensystem(qmk)
tmp, ubov_mk = GLSW.eigensystem(-k)
tmp, ubov_mqmk = GLSW.eigensystem(-qmk)
tmpmat1 = ek[:2 * num_sub][:, None]
tmpmat2 = eqmk[:2 * num_sub][None, :]
esum = tmpmat1 + tmpmat2
#denomin = eq[:2*num_sub, None, None] - esum[None, :, :] + 1j*cgf
denomin = eq[None, None, :2 * num_sub] - esum[:, :, None] + 1j * cgf
#v_decay = vertex.V_cubic_decay(q, k, qmk, ubov_q, ubov_k, ubov_qmk, \
# ubov_mq, ubov_mk, ubov_mqmk)
v_decay = vertex.V_cubic_decay(k, qmk, q, ubov_k, ubov_qmk, ubov_q, \
ubov_mk, ubov_mqmk, ubov_mq)
Intmat = (v_decay.conj() * v_decay) / denomin
# 0.5 is the symmetry factor, return to the "on-shell" self-energy
# for all bands
Intvec = 0.5 * Intmat.sum(axis=(0, 1))
for band in range(2 * num_sub):
ff[2 * band] = np.real(Intvec[band])
ff[2 * band + 1] = np.imag(Intvec[band])
return 0
print_header('Vegas')
"""
vegas:
pycuba.Vegas(integrand, ndim, userdata, epsrel=0.001, epsabs=1e-12, \
verbose=0, ncomp=1, seed=None, minevel=0, maxeval=50000, \
nstart=1000, nincrease=500, nbatch=1000, gridno=0, statefile=, \
nvec=1)
"""
res = pycuba.Vegas(integrand_decay, NDIM, epsabs = 1e-5, \
verbose=2, ncomp=4*num_sub, maxeval=10000)
"""
The return value is always a dictionary:
{ 'neval': number of evaluations,
'fail': 0 or 1,
'comp': number of components, usually 1,
'nregions': number of regions used,
'results': [ # a list of results for each component
{
'integral': value of the integral,
'error': uncertainty,
'prob': probability (see manual),
},
...
]
}
"""
print_results('Vegas', res)
rres = res.get('results')
len_rres = len(rres)
iintegrals = np.zeros(len_rres)
for flag in range(len_rres):
iintegrals[flag] = rres[flag].get('integral')
return iintegrals