def test_from_scipy_sparse(scipy_type, CLS, dtype):
orig = scipy.sparse.random(20,
30,
density=0.2,
format=scipy_type,
dtype=dtype)
ref = COO.from_scipy_sparse(orig)
result = CLS.from_scipy_sparse(orig)
assert_eq(ref, result)
result_via_init = CLS(orig)
assert_eq(ref, result_via_init)
def test_scipy_sparse_interface():
n = 100
m = 10
row = np.random.randint(0, n, size=n, dtype=np.uint16)
col = np.random.randint(0, m, size=n, dtype=np.uint16)
data = np.ones(n, dtype=np.uint8)
inp = (data, (row, col))
x = scipy.sparse.coo_matrix(inp)
xx = sparse.COO(inp)
assert_eq(x, xx)
assert_eq(x.T, xx.T)
assert_eq(xx.to_scipy_sparse(), x)
assert_eq(COO.from_scipy_sparse(xx.to_scipy_sparse()), xx)
assert_eq(x, xx)
assert_eq(x.T.dot(x), xx.T.dot(xx))
def from_scipy_sparse(cls, x):
"""
Create a :obj:`DOK` array from a :obj:`scipy.sparse.spmatrix`.
Parameters
----------
x : scipy.sparse.spmatrix
The matrix to convert.
Returns
-------
DOK
The equivalent :obj:`DOK` array.
Examples
--------
>>> x = scipy.sparse.rand(6, 3, density=0.2)
>>> s = DOK.from_scipy_sparse(x)
>>> np.array_equal(x.todense(), s.todense())
True
"""
from sparse import COO
return COO.from_scipy_sparse(x).asformat(cls)
def load(cls,
folder,
supercell=(1, 1, 1),
format='sparse',
third_energy_threshold=0.):
"""
Create a finite difference object from a folder
:param folder:
:param supercell:
:param format:
:param third_energy_threshold:
:param is_acoustic_sum:
:return:
"""
if format == 'sparse':
if folder[-1] != '/':
folder = folder + '/'
try:
config_file = folder + REPLICATED_ATOMS_THIRD_FILE
replicated_atoms = ase.io.read(config_file, format='extxyz')
except FileNotFoundError:
config_file = folder + REPLICATED_ATOMS_FILE
replicated_atoms = ase.io.read(config_file, format='extxyz')
n_replicas = np.prod(supercell)
n_total_atoms = replicated_atoms.positions.shape[0]
n_unit_atoms = int(n_total_atoms / n_replicas)
unit_symbols = []
unit_positions = []
for i in range(n_unit_atoms):
unit_symbols.append(replicated_atoms.get_chemical_symbols()[i])
unit_positions.append(replicated_atoms.positions[i])
unit_cell = replicated_atoms.cell / supercell
atoms = Atoms(unit_symbols,
positions=unit_positions,
cell=unit_cell,
pbc=[1, 1, 1])
_third_order = COO.from_scipy_sparse(load_npz(folder + THIRD_ORDER_FILE_SPARSE)) \
.reshape((n_unit_atoms * 3, n_replicas * n_unit_atoms * 3, n_replicas * n_unit_atoms * 3))
third_order = ThirdOrder(
atoms=atoms,
replicated_positions=replicated_atoms.positions,
supercell=supercell,
value=_third_order,
folder=folder)
elif format == 'eskm' or format == 'lammps':
if format == 'eskm':
config_file = str(folder) + "/CONFIG"
replicated_atoms = ase.io.read(config_file, format='dlp4')
elif format == 'lammps':
config_file = str(folder) + "/replicated_atoms.xyz"
replicated_atoms = ase.io.read(config_file, format='extxyz')
third_file = str(folder) + "/THIRD"
n_replicas = np.prod(supercell)
n_total_atoms = replicated_atoms.positions.shape[0]
n_unit_atoms = int(n_total_atoms / n_replicas)
unit_symbols = []
unit_positions = []
for i in range(n_unit_atoms):
unit_symbols.append(replicated_atoms.get_chemical_symbols()[i])
unit_positions.append(replicated_atoms.positions[i])
unit_cell = replicated_atoms.cell / supercell
atoms = Atoms(unit_symbols,
positions=unit_positions,
cell=unit_cell,
pbc=[1, 1, 1])
out = import_from_files(
replicated_atoms=replicated_atoms,
third_file=third_file,
supercell=supercell,
third_energy_threshold=third_energy_threshold)
third_order = ThirdOrder(
atoms=atoms,
replicated_positions=replicated_atoms.positions,
supercell=supercell,
value=out[1],
folder=folder)
elif format == 'shengbte' or format == 'shengbte-qe':
grid_type = 'F'
config_file = folder + '/' + 'CONTROL'
try:
atoms, supercell = shengbte_io.import_control_file(config_file)
except FileNotFoundError as err:
config_file = folder + '/' + 'POSCAR'
logging.info('\nTrying to open POSCAR')
atoms = ase.io.read(config_file)
third_file = folder + '/' + 'FORCE_CONSTANTS_3RD'
third_order = shengbte_io.read_third_order_matrix(third_file,
atoms,
supercell,
order='C')
third_order = ThirdOrder.from_supercell(atoms=atoms,
grid_type=grid_type,
supercell=supercell,
value=third_order,
folder=folder)
elif format == 'hiphive':
filename = 'atom_prim.xyz'
# TODO: add replicated filename in example
replicated_filename = 'replicated_atoms.xyz'
try:
import kaldo.interface.hiphive_io as hiphive_io
except ImportError:
logging.error(
'In order to use hiphive along with kaldo, hiphive is required. \
Please consider installing hihphive. More info can be found at: \
https://hiphive.materialsmodeling.org/')
atom_prime_file = str(folder) + '/' + filename
replicated_atom_prime_file = str(
folder) + '/' + replicated_filename
# TODO: Make this independent of replicated file
atoms = ase.io.read(atom_prime_file)
replicated_atoms = ase.io.read(replicated_atom_prime_file)
if 'model3.fcs' in os.listdir(str(folder)):
# Derive constants used for third-order reshape
supercell = np.array(supercell)
n_prim = atoms.copy().get_masses().shape[0]
n_sc = np.prod(supercell)
dim = len(supercell[supercell > 1])
_third_order = hiphive_io.import_third_from_hiphive(
atoms, supercell, folder)
_third_order = _third_order[0].reshape(n_prim * dim,
n_sc * n_prim * dim,
n_sc * n_prim * dim)
third_order = cls(
atoms=atoms,
replicated_positions=replicated_atoms.positions,
supercell=supercell,
value=_third_order,
folder=folder)
else:
logging.error('Third order format not recognized: ' + str(format))
raise ValueError
return third_order
