def test_unl(self):
"""
Consider a pole at omega=pole. Compare analytic results of G(iwn) and numerical results computed by using unl.
"""
for _lambda in [10.0, 1E+4, 1E+7]:
for _statistics, pole in product(["f", "b"], [1.0, 0.1]):
print("lambda = %d, stat = %s, y = %g" %
(_lambda, repr(_statistics), pole))
prefix = "basis_" + _statistics + "-mp-Lambda" + str(_lambda)
basis = ir.basis("../irbasis.h5", prefix)
dim = basis.dim()
wmax = 1.0
beta = _lambda / wmax
if _statistics == 'f':
rho_l = numpy.sqrt(1 / wmax) * numpy.array(
[basis.vly(l, pole / wmax) for l in range(dim)])
Sl = numpy.sqrt(0.5 * beta * wmax) * numpy.array(
[basis.sl(l) for l in range(dim)])
stat_shift = 1
else:
rho_l = numpy.sqrt(1 / wmax) * numpy.array(
[basis.vly(l, pole / wmax) for l in range(dim)]) / pole
Sl = numpy.sqrt(0.5 * beta * wmax**3) * numpy.array(
[basis.sl(l) for l in range(dim)])
stat_shift = 0
gl = -Sl * rho_l
def G(n):
wn = (2 * n + stat_shift) * numpy.pi / beta
z = 1J * wn
return 1 / (z - pole)
# Compute G(iwn) using unl
n_plt = numpy.array([
-1, 0, 1, 1E+1, 1E+2, 1E+3, 1E+4, 1E+5, 1E+6, 1E+7, 1E+8,
1E+9, 1E+10, 1E+14
],
dtype=int)
Uwnl_plt = numpy.sqrt(beta) * basis.compute_unl(n_plt)
Giwn_t = numpy.dot(Uwnl_plt, gl)
# Compute G(iwn) from analytic expression
Giwn_ref = numpy.array([G(n) for n in n_plt])
magnitude = numpy.abs(Giwn_ref).max()
diff = numpy.abs(Giwn_t - Giwn_ref)
reldiff = diff / numpy.abs(Giwn_ref)
# Absolute error must be smaller than 1e-12
print("max. absdiff = %.4g, rel = %.4g" %
(diff.max() / magnitude, reldiff.max()))
self.assertLessEqual((diff / magnitude).max(), 5e-13)
# Relative error must be smaller than 1e-12
self.assertLessEqual(numpy.amax(numpy.abs(diff / Giwn_ref)),
5e-13)
def test_unl(self):
for _lambda in [10.0, 10000.0]:
for _statistics in ["f", "b"]:
prefix = "basis_" + _statistics + "-mp-Lambda" + str(_lambda)
rf_ref = refdata("../unl_safe_ref.h5", prefix)
basis = ir.basis("../irbasis.h5", prefix + "_np8")
diff = rf_ref.check_data(basis, _statistics)
self.assertLessEqual(diff[0], 1e-8)
self.assertLessEqual(diff[1], 1e-7)
def test_vectorized_ulx(self):
for _lambda in [10.0]:
prefix = "basis_b-mp-Lambda" + str(_lambda) + "_np8"
rb = ir.basis("../irbasis.h5", prefix)
x = 0.1
ulx_data = rb.ulx_all_l(x)
for l in range(rb.dim()):
self.assertAlmostEqual(ulx_data[l], rb.ulx(l, x), delta=1e-10)
def test_small_lambda_b(self):
for _lambda in [10.0, 10000.0]:
prefix = "basis_b-mp-Lambda" + str(_lambda) + "_np8"
rb = ir.basis("../irbasis.h5", prefix)
check_data_ulx = rb._check_ulx()
for _data in check_data_ulx:
self.assertLessEqual(_data[2], 1e-8)
check_data_vly = rb._check_vly()
for _data in check_data_vly:
self.assertLessEqual(_data[2], 1e-8)
def test_ulx(self):
for _lambda in [10.0, 1E+4, 1E+7]:
prefix = "basis_f-mp-Lambda" + str(_lambda)
rb = ir.basis("../irbasis.h5", prefix)
d_ulx_ref = rb._get_d_ulx_ref()
num_ref_data = d_ulx_ref.shape[0]
tol = {0: 1e-10, 1: 1e-10, 2: 1e-5}
for i_ref_data in range(num_ref_data):
Nl, x, order, ref_val = d_ulx_ref[i_ref_data, :]
Nl = int(Nl)
order = int(order)
val = rb.d_ulx(Nl - 1, x, order)
adiff = abs(ref_val - val)
rdiff = adiff / ref_val
print(Nl, x, order, ref_val, val, rdiff)
self.assertTrue(rdiff < tol[order] or adiff < tol[order])
def test_to_Gl(self):
for _lambda in [10.0, 10000.0]:
for _statistics in ["f", "b"]:
beta = 10.0
prefix = "basis_" + _statistics + "-mp-Lambda" + str(_lambda)
basis = ir.basis("../irbasis.h5", prefix)
Nl = basis.dim()
trans = transformer(basis, beta)
# Trivial test
gtau = lambda tau: basis.ulx(Nl - 1, 2 * tau / beta - 1)
gl = trans.compute_gl(gtau, Nl)
for l in range(Nl - 1):
self.assertLessEqual(numpy.abs(gl[l]), 1e-8)
self.assertLessEqual(numpy.abs(gl[-1] - numpy.sqrt(beta / 2)),
1e-8)
def test_differential_ulx(self):
for _lambda in [10.0, 10000.0]:
prefix = "basis_f-mp-Lambda" + str(_lambda) + "_np8"
rb_np8 = ir.basis("../irbasis.h5", prefix)
d_ulx_ref_np8 = rb_np8._get_d_ulx_ref()
d_ulx_ref_np8_1st = d_ulx_ref_np8[d_ulx_ref_np8[:, 2] == 1][0][3]
d_ulx_ref_np8_2nd = d_ulx_ref_np8[d_ulx_ref_np8[:, 2] == 2][0][3]
# 1-st differential
Nl = rb_np8.dim()
if Nl % 2 == 1: Nl -= 1
d_1st_differential = abs(
(d_ulx_ref_np8_1st - rb_np8.d_ulx(Nl - 1, 1.0, 1)) /
d_ulx_ref_np8_1st)
self.assertLessEqual(d_1st_differential, 1e-8)
# 2-nd differential
d_2nd_differential = abs(
(d_ulx_ref_np8_2nd - rb_np8.d_ulx(Nl - 1, 1.0, 2)) /
d_ulx_ref_np8_2nd)
self.assertLessEqual(d_2nd_differential, 1e-8)
def test_vectorization(self):
for _lambda in [1E+4]:
prefix = "basis_f-mp-Lambda" + str(_lambda)
rb = ir.basis("../irbasis.h5", prefix)
# re-vectorized functions
revec_ulx = numpy.vectorize(rb.ulx)
revec_vly = numpy.vectorize(rb.vly)
revec_sl = numpy.vectorize(rb.sl)
# check that those match:
x = numpy.array([-.3, .2, .5])
l = numpy.array([1, 3, 10, 15], dtype=int)
alll = numpy.arange(rb.dim())
self.assertTrue(numpy.allclose(revec_sl(l), rb.sl(l)))
self.assertTrue(numpy.allclose(revec_sl(alll), rb.sl()))
self.assertTrue(numpy.allclose(revec_ulx(l[0], x), rb.ulx(l[0],
x)))
self.assertTrue(numpy.allclose(revec_ulx(l, x[0]), rb.ulx(l,
x[0])))
self.assertTrue(
numpy.allclose(revec_ulx(alll, x[0]), rb.ulx(None, x[0])))
self.assertTrue(
numpy.allclose(revec_ulx(l[:, None], x[None, :]),
rb.ulx(l[:, None], x[None, :])))
self.assertTrue(numpy.allclose(revec_vly(l[0], x), rb.vly(l[0],
x)))
self.assertTrue(numpy.allclose(revec_vly(l, x[0]), rb.vly(l,
x[0])))
self.assertTrue(
numpy.allclose(revec_vly(alll, x[0]), rb.vly(None, x[0])))
self.assertTrue(
numpy.allclose(revec_vly(l[:, None], x[None, :]),
rb.vly(l[:, None], x[None, :])))
def test_unl(self):
for _lambda in [10000.0]:
prefix = "basis_f-mp-Lambda" + str(_lambda) + "_np10"
rf = ir.basis("../irbasis.h5", prefix)
unl = rf.compute_unl([0, 1, 2])
