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])