def test_caching():
x = COO({(10, 10, 10): 1})
assert x[:].reshape((100, 10)).transpose().tocsr() is not x[:].reshape((100, 10)).transpose().tocsr()
x = COO({(10, 10, 10): 1}, cache=True)
assert x[:].reshape((100, 10)).transpose().tocsr() is x[:].reshape((100, 10)).transpose().tocsr()
x = COO({(1, 1, 1, 1, 1, 1, 1, 2): 1}, cache=True)
for i in range(x.ndim):
x.reshape((1,) * i + (2,) + (1,) * (x.ndim - i - 1))
assert len(x._cache['reshape']) < 5
def test_caching():
x = COO({(9, 9, 9): 1})
assert (x[:].reshape((100, 10)).transpose().tocsr() is not x[:].reshape(
(100, 10)).transpose().tocsr())
x = COO({(9, 9, 9): 1}, cache=True)
assert (x[:].reshape((100, 10)).transpose().tocsr() is x[:].reshape(
(100, 10)).transpose().tocsr())
x = COO({(1, 1, 1, 1, 1, 1, 1, 2): 1}, cache=True)
for i in range(x.ndim):
x.reshape(x.size)
assert len(x._cache["reshape"]) < 5
def test_large_reshape():
n = 100
m = 10
row = np.arange(n, dtype=np.uint16) # np.random.randint(0, n, size=n, dtype=np.uint16)
col = row % m # np.random.randint(0, m, size=n, dtype=np.uint16)
data = np.ones(n, dtype=np.uint8)
x = COO((data, (row, col)), sorted=True, has_duplicates=False)
assert_eq(x, x.reshape(x.shape))
def unfold_third_order(self, reduced_third=None, distance_threshold=None):
"""
This method extrapolates a third order force constant matrix from a unit
cell into a matrix for a larger supercell.
Parameters
----------
reduced_third : array, optional
The third order force constant matrix.
Default is `self.third`
distance_threshold : float, optional
When calculating force constants, contributions from atoms further than
the distance threshold will be ignored.
Default is self.distance_threshold
"""
logging.info('Unfolding third order matrix')
if distance_threshold is None:
if self.distance_threshold is not None:
distance_threshold = self.distance_threshold
else:
raise ValueError(
'Please specify a distance threshold in Angstrom')
logging.info('Distance threshold: ' + str(distance_threshold) + ' A')
if (self.atoms.cell[0, 0] / 2 < distance_threshold) | \
(self.atoms.cell[1, 1] / 2 < distance_threshold) | \
(self.atoms.cell[2, 2] / 2 < distance_threshold):
logging.warning(
'The cell size should be at least twice the distance threshold'
)
if reduced_third is None:
reduced_third = self.third.value
n_unit_atoms = self.n_atoms
atoms = self.atoms
n_replicas = self.n_replicas
replicated_cell_inv = np.linalg.inv(self.third.replicated_atoms.cell)
reduced_third = reduced_third.reshape(
(n_unit_atoms, 3, n_replicas, n_unit_atoms, 3, n_replicas,
n_unit_atoms, 3))
replicated_positions = self.third.replicated_atoms.positions.reshape(
(n_replicas, n_unit_atoms, 3))
dxij_reduced = wrap_coordinates(
atoms.positions[:, np.newaxis, np.newaxis, :] -
replicated_positions[np.newaxis, :, :, :],
self.third.replicated_atoms.cell, replicated_cell_inv)
indices = np.argwhere(
np.linalg.norm(dxij_reduced, axis=-1) < distance_threshold)
coords = []
values = []
for index in indices:
for l in range(n_replicas):
for j in range(n_unit_atoms):
dx2 = dxij_reduced[index[0], l, j]
is_storing = (np.linalg.norm(dx2) < distance_threshold)
if is_storing:
for alpha in range(3):
for beta in range(3):
for gamma in range(3):
coords.append([
index[0], alpha, index[1], index[2],
beta, l, j, gamma
])
values.append(reduced_third[index[0],
alpha, 0,
index[2], beta,
0, j, gamma])
logging.info('Created unfolded third order')
shape = (n_unit_atoms, 3, n_replicas, n_unit_atoms, 3, n_replicas,
n_unit_atoms, 3)
expanded_third = COO(np.array(coords).T, np.array(values), shape)
expanded_third = expanded_third.reshape(
(n_unit_atoms * 3, n_replicas * n_unit_atoms * 3,
n_replicas * n_unit_atoms * 3))
return expanded_third
def optimize_onesite(forward, mpo0, lopr, ropr, wfn0, wfn1, M, tol):
"""
Optimization for onesite algorithm.
Parameters
----------
forward : int
0 for left and 1 for right.
mpo0 : ndarray
MPO.
lopr : ndarray
left block opr.
ropr : ndarray
right block opr.
wfn0 : ndarray
MPS for canonicalization.
wfn1 : ndarray
MPS.
M : int
bond dimension
Returns
-------
energy : float or list of floats
The energy of desired root(s).
"""
#diag_flat = diag_onesite(mpo0, lopr, ropr).ravel()
diag_flat = diag_onesite(mpo0, lopr, ropr).ravel().todense()
mps_shape = wfn0.shape
def dot_flat(x):
#return dot_onesite(mpo0, lopr, ropr, x.reshape(mps_shape)).ravel()
return dot_onesite(mpo0, lopr, ropr,
COO(x.reshape(mps_shape))).ravel().todense()
def compute_precond_flat(dx, e, x0):
#return COO(dx.todense() / (diag_flat.todense() - e))
return dx / (diag_flat - e)
#dot_func = sparse.coo.common.dot
dot_func = np.dot
#energy, wfn0 = linalg_helper.davidson(dot_flat, wfn0.ravel(), compute_precond_flat, tol = tol, dot = dot_func)
energy, wfn0 = linalg_helper.davidson(dot_flat,
wfn0.ravel().todense(),
compute_precond_flat,
tol=tol,
dot=dot_func)
#wfn0 = wfn0.reshape(mps_shape)
wfn0 = COO(wfn0.reshape(mps_shape))
if forward:
wfn0, gaug = canonicalize(1, wfn0, M) # wfn0 R => lmps gaug
wfn1 = einsum("ij,jkl->ikl", gaug, wfn1)
lopr = renormalize(1, mpo0, lopr, wfn0.conj(), wfn0)
return energy, wfn0, wfn1, lopr
else:
wfn0, gaug = canonicalize(0, wfn0, M) # wfn0 R => lmps gaug
wfn1 = einsum("ijk,kl->ijl", wfn1, gaug)
ropr = renormalize(0, mpo0, ropr, wfn0.conj(), wfn0)
return energy, wfn0, wfn1, ropr
def read_third_order_matrix_2(third_file, atoms, third_supercell, order='C'):
supercell = third_supercell
n_unit_atoms = atoms.positions.shape[0]
n_replicas = np.prod(supercell)
current_grid = Grid(third_supercell, order=order).grid(is_wrapping=True)
list_of_index = current_grid
list_of_replicas = list_of_index.dot(atoms.cell)
replicated_cell = atoms.cell * supercell
# replicated_cell_inv = np.linalg.inv(replicated_cell)
coords = []
data = []
second_cell_positions = []
third_cell_positions = []
atoms_coords = []
sparse_data = []
with open(third_file, 'r') as file:
line = file.readline()
n_third = int(line)
for i in range(n_third):
file.readline()
file.readline()
second_cell_position = np.fromstring(file.readline(),
dtype=np.float,
sep=' ')
second_cell_positions.append(second_cell_position)
d_1 = list_of_replicas[:, :] - second_cell_position[np.newaxis, :]
# d_1 = wrap_coordinates(d_1, replicated_cell, replicated_cell_inv)
mask_second = np.linalg.norm(d_1, axis=1) < 1e-5
second_cell_id = np.argwhere(mask_second).flatten()
third_cell_position = np.fromstring(file.readline(),
dtype=np.float,
sep=' ')
third_cell_positions.append(third_cell_position)
d_2 = list_of_replicas[:, :] - third_cell_position[np.newaxis, :]
# d_2 = wrap_coordinates(d_2, replicated_cell, replicated_cell_inv)
mask_third = np.linalg.norm(d_2, axis=1) < 1e-5
third_cell_id = np.argwhere(mask_third).flatten()
atom_i, atom_j, atom_k = np.fromstring(
file.readline(), dtype=np.int, sep=' ') - 1
atoms_coords.append([atom_i, atom_j, atom_k])
small_data = []
for _ in range(27):
values = np.fromstring(file.readline(),
dtype=np.float,
sep=' ')
alpha, beta, gamma = values[:3].round(0).astype(int) - 1
coords.append([
atom_i, alpha, second_cell_id, atom_j, beta, third_cell_id,
atom_k, gamma
])
data.append(values[3])
small_data.append(values[3])
sparse_data.append(small_data)
third_order = COO(np.array(coords).T,
np.array(data),
shape=(n_unit_atoms, 3, n_replicas, n_unit_atoms, 3,
n_replicas, n_unit_atoms, 3))
third_order = third_order.reshape(
(n_unit_atoms * 3, n_replicas * n_unit_atoms * 3,
n_replicas * n_unit_atoms * 3))
return third_order, np.array(sparse_data), np.array(
second_cell_positions), np.array(third_cell_positions), np.array(
atoms_coords)
