def test_spherical_complete(self):
"""Test atomitc grid consistence for spherical integral."""
num_pts = len(LEBEDEV_DEGREES)
pts = HortonLinear(num_pts)
for _ in range(10):
start = np.random.rand() * 1e-5
end = np.random.rand() * 10 + 10
tf = PowerRTransform(start, end)
rad_grid = tf.transform_1d_grid(pts)
atgrid = AtomGrid(rad_grid, degrees=list(LEBEDEV_DEGREES.keys()))
values = np.random.rand(len(LEBEDEV_DEGREES))
pt_val = np.zeros(atgrid.size)
for index, value in enumerate(values):
pt_val[atgrid._indices[index]:atgrid._indices[index +
1]] = value
rad_int_val = (value * rad_grid.weights[index] * 4 * np.pi *
rad_grid.points[index]**2)
atgrid_int_val = np.sum(
pt_val[atgrid._indices[index]:atgrid._indices[index + 1]] *
atgrid.weights[atgrid._indices[index]:atgrid.
_indices[index + 1]])
assert_almost_equal(rad_int_val, atgrid_int_val)
ref_int_at = atgrid.integrate(pt_val)
ref_int_rad = rad_grid.integrate(4 * np.pi * rad_grid.points**2 *
values)
assert_almost_equal(ref_int_at, ref_int_rad)
def test_power_basics(self):
"""Test power tf."""
cases = self.get_power_cases()
for rmin, rmax in cases:
gd = np.ones(100) * 99
rtf = PowerRTransform(rmin, rmax)
assert abs(rtf.transform(gd)[0] - rmax) < 1e-9
self.check_consistency(rtf)
self.check_deriv(rtf)
def test_integrate_gauss():
"""Test radial grid integral."""
oned = UniformInteger(100)
rtf = PowerRTransform(0.0005, 1e1)
grid = rtf.transform_1d_grid(oned)
assert isinstance(grid, OneDGrid)
y = np.exp(-0.5 * grid.points ** 2)
# time 4 \pi and r^2 to accommodate old horton test
grid._weights = grid.weights * 4 * np.pi * grid.points ** 2
assert_almost_equal(grid.integrate(y), (2 * np.pi) ** 1.5)
def test_power_properties(self):
"""Test power tf properties."""
cases = self.get_power_cases()
for rmin, rmax in cases:
rtf = PowerRTransform(rmin, rmax)
assert rtf.rmin == rmin
assert rtf.rmax == rmax
def test_power_bounds(self):
"""Test power tf raise errors."""
with self.assertRaises(ValueError):
PowerRTransform(-1.0, 2.0)
with self.assertRaises(ValueError):
PowerRTransform(0.1, -2.0)
with self.assertWarns(RuntimeWarning):
a = np.ones(50)
tf = PowerRTransform(1.0, 1.1)
tf.transform(a)
with self.assertRaises(ValueError):
PowerRTransform(1.1, 1.0)
def test_domain(self):
"""Test domain errors."""
rad = GaussLegendre(10)
with self.assertRaises(ValueError):
tf = IdentityRTransform()
tf.transform_1d_grid(rad)
with self.assertRaises(ValueError):
tf = LinearInfiniteRTransform(0.1, 1.5)
tf.transform_1d_grid(rad)
with self.assertRaises(ValueError):
tf = ExpRTransform(0.1, 1e1)
tf.transform_1d_grid(rad)
with self.assertRaises(ValueError):
tf = PowerRTransform(1e-3, 1e2)
tf.transform_1d_grid(rad)
with self.assertRaises(ValueError):
tf = HyperbolicRTransform(0.4 / 450, 1.0 / 450)
tf.transform_1d_grid(rad)
def test_from_predefined(self):
"""Test grid construction with predefined grid."""
# test coarse grid
pts = HortonLinear(20)
tf = PowerRTransform(7.0879993828935345e-06, 16.05937640019924)
rad_grid = tf.transform_1d_grid(pts)
atgrid = AtomGrid.from_preset(rad_grid, atnum=1, preset="coarse")
# 604 points for coarse H atom
assert_equal(atgrid.size, 604)
assert_almost_equal(
np.sum(np.exp(-np.sum(atgrid.points**2, axis=1)) * atgrid.weights),
5.56840953,
)
# test medium grid
pts = HortonLinear(24)
tf = PowerRTransform(3.69705074304963e-06, 19.279558946793685)
rad_grid = tf.transform_1d_grid(pts)
atgrid = AtomGrid.from_preset(rad_grid, atnum=1, preset="medium")
# 928 points for coarse H atom
assert_equal(atgrid.size, 928)
assert_almost_equal(
np.sum(np.exp(-np.sum(atgrid.points**2, axis=1)) * atgrid.weights),
5.56834559,
)
# test fine grid
pts = HortonLinear(34)
tf = PowerRTransform(2.577533167224667e-07, 16.276983371222354)
rad_grid = tf.transform_1d_grid(pts)
atgrid = AtomGrid.from_preset(rad_grid, atnum=1, preset="fine")
# 1984 points for coarse H atom
assert_equal(atgrid.size, 1984)
assert_almost_equal(
np.sum(np.exp(-np.sum(atgrid.points**2, axis=1)) * atgrid.weights),
5.56832800,
)
# test veryfine grid
pts = HortonLinear(41)
tf = PowerRTransform(1.1774580743206259e-07, 20.140888089596444)
rad_grid = tf.transform_1d_grid(pts)
atgrid = AtomGrid.from_preset(rad_grid, atnum=1, preset="veryfine")
# 3154 points for coarse H atom
assert_equal(atgrid.size, 3154)
assert_almost_equal(
np.sum(np.exp(-np.sum(atgrid.points**2, axis=1)) * atgrid.weights),
5.56832800,
)
# test ultrafine grid
pts = HortonLinear(49)
tf = PowerRTransform(4.883104847991021e-08, 21.05456999309752)
rad_grid = tf.transform_1d_grid(pts)
atgrid = AtomGrid.from_preset(rad_grid, atnum=1, preset="ultrafine")
# 4546 points for coarse H atom
assert_equal(atgrid.size, 4546)
assert_almost_equal(
np.sum(np.exp(-np.sum(atgrid.points**2, axis=1)) * atgrid.weights),
5.56832800,
)
# test insane grid
pts = HortonLinear(59)
tf = PowerRTransform(1.9221827244049134e-08, 21.413278983919113)
rad_grid = tf.transform_1d_grid(pts)
atgrid = AtomGrid.from_preset(rad_grid, atnum=1, preset="insane")
# 6622 points for coarse H atom
assert_equal(atgrid.size, 6622)
assert_almost_equal(
np.sum(np.exp(-np.sum(atgrid.points**2, axis=1)) * atgrid.weights),
5.56832800,
)