def calc(self, item):
"""
Process the tasks and materials into a dielectrics collection
Args:
item dict: a dict of material_id, structure, and tasks
Returns:
dict: a dieletrics dictionary
"""
def poly(matrix):
diags = np.diagonal(matrix)
return np.prod(diags) / np.sum(
np.prod(comb) for comb in combinations(diags, 2))
if item["bandstructure"]["band_gap"] > 0:
structure = Structure.from_dict(
item.get("dielectric", {}).get("structure", None))
ionic = Tensor(
item["dielectric"]["ionic"]).convert_to_ieee(structure)
static = Tensor(
item["dielectric"]["static"]).convert_to_ieee(structure)
total = ionic + static
d = {
"dielectric": {
"total": total,
"ionic": ionic,
"static": static,
"e_total": np.average(np.diagonal(total)),
"e_ionic": np.average(np.diagonal(ionic)),
"e_static": np.average(np.diagonal(static)),
"n": np.sqrt(np.average(np.diagonal(static))),
}
}
sga = SpacegroupAnalyzer(structure)
# Update piezo if non_centrosymmetric
if item.get("piezo", False) and not sga.is_laue():
static = PiezoTensor.from_voigt(
np.array(item["piezo"]["static"]))
ionic = PiezoTensor.from_voigt(np.array(
item["piezo"]["ionic"]))
total = ionic + static
# Symmeterize Convert to IEEE orientation
total = total.convert_to_ieee(structure)
ionic = ionic.convert_to_ieee(structure)
static = static.convert_to_ieee(structure)
directions, charges, strains = np.linalg.svd(
total.voigt, full_matrices=False)
max_index = np.argmax(np.abs(charges))
max_direction = directions[max_index]
# Allow a max miller index of 10
min_val = np.abs(max_direction)
min_val = min_val[min_val > (np.max(min_val) /
self.max_miller)]
min_val = np.min(min_val)
d["piezo"] = {
"total": total.zeroed().voigt,
"ionic": ionic.zeroed().voigt,
"static": static.zeroed().voigt,
"e_ij_max": charges[max_index],
"max_direction": np.round(max_direction / min_val),
"strain_for_max": strains[max_index],
}
else:
d = {
"dielectric": {},
"_warnings": [
"Dielectric calculated for likely metal. Values are unlikely to be converged"
],
}
if item.get("piezo", False):
d.update({
"piezo": {},
"_warnings": [
"Piezoelectric calculated for likely metal. Values are unlikely to be converged"
],
})
return d
class TensorTest(PymatgenTest):
_multiprocess_shared_ = True
def setUp(self):
self.vec = Tensor([1.0, 0.0, 0.0])
self.rand_rank2 = Tensor(np.random.randn(3, 3))
self.rand_rank3 = Tensor(np.random.randn(3, 3, 3))
self.rand_rank4 = Tensor(np.random.randn(3, 3, 3, 3))
a = 3.14 * 42.5 / 180
self.non_symm = SquareTensor([[0.1, 0.2, 0.3], [0.4, 0.5, 0.6],
[0.2, 0.5, 0.5]])
self.rotation = SquareTensor([[math.cos(a), 0,
math.sin(a)], [0, 1, 0],
[-math.sin(a), 0,
math.cos(a)]])
self.low_val = Tensor([[1e-6, 1 + 1e-5, 1e-6], [1 + 1e-6, 1e-6, 1e-6],
[1e-7, 1e-7, 1 + 1e-5]])
self.symm_rank2 = Tensor([[1, 2, 3], [2, 4, 5], [3, 5, 6]])
self.symm_rank3 = Tensor([
[[1, 2, 3], [2, 4, 5], [3, 5, 6]],
[[2, 4, 5], [4, 7, 8], [5, 8, 9]],
[[3, 5, 6], [5, 8, 9], [6, 9, 10]],
])
self.symm_rank4 = Tensor([
[
[[1.2, 0.4, -0.92], [0.4, 0.05, 0.11], [-0.92, 0.11, -0.02]],
[[0.4, 0.05, 0.11], [0.05, -0.47, 0.09], [0.11, 0.09, -0.0]],
[[-0.92, 0.11, -0.02], [0.11, 0.09, 0.0], [-0.02, 0.0, -0.3]],
],
[
[[0.4, 0.05, 0.11], [0.05, -0.47, 0.09], [0.11, 0.09, 0.0]],
[[0.05, -0.47, 0.09], [-0.47, 0.17, 0.62], [0.09, 0.62, 0.3]],
[[0.11, 0.09, 0.0], [0.09, 0.62, 0.3], [0.0, 0.3, -0.18]],
],
[
[[-0.92, 0.11, -0.02], [0.11, 0.09, 0.0], [-0.02, 0, -0.3]],
[[0.11, 0.09, 0.0], [0.09, 0.62, 0.3], [0.0, 0.3, -0.18]],
[[-0.02, 0.0, -0.3], [0.0, 0.3, -0.18], [-0.3, -0.18, -0.51]],
],
])
# Structural symmetries tested using BaNiO3 piezo/elastic tensors
self.fit_r3 = Tensor([
[[0.0, 0.0, 0.03839], [0.0, 0.0, 0.0], [0.03839, 0.0, 0.0]],
[[0.0, 0.0, 0.0], [0.0, 0.0, 0.03839], [0.0, 0.03839, 0.0]],
[[6.89822, 0.0, 0.0], [0.0, 6.89822, 0.0], [0.0, 0.0, 27.4628]],
])
self.fit_r4 = Tensor([
[
[[157.9, 0.0, 0.0], [0.0, 63.1, 0.0], [0.0, 0.0, 29.4]],
[[0.0, 47.4, 0.0], [47.4, 0.0, 0.0], [0.0, 0.0, 0.0]],
[[0.0, 0.0, 4.3], [0.0, 0.0, 0.0], [4.3, 0.0, 0.0]],
],
[
[[0.0, 47.4, 0.0], [47.4, 0.0, 0.0], [0.0, 0.0, 0.0]],
[[63.1, 0.0, 0.0], [0.0, 157.9, 0.0], [0.0, 0.0, 29.4]],
[[0.0, 0.0, 0.0], [0.0, 0.0, 4.3], [0.0, 4.3, 0.0]],
],
[
[[0.0, 0.0, 4.3], [0.0, 0.0, 0.0], [4.3, 0.0, 0.0]],
[[0.0, 0.0, 0.0], [0.0, 0.0, 4.3], [0.0, 4.3, 0.0]],
[[29.4, 0.0, 0.0], [0.0, 29.4, 0.0], [0.0, 0.0, 207.6]],
],
])
self.unfit4 = Tensor([
[
[[161.26, 0.0, 0.0], [0.0, 62.76, 0.0], [0.0, 0.0, 30.18]],
[[0.0, 47.08, 0.0], [47.08, 0.0, 0.0], [0.0, 0.0, 0.0]],
[[0.0, 0.0, 4.23], [0.0, 0.0, 0.0], [4.23, 0.0, 0.0]],
],
[
[[0.0, 47.08, 0.0], [47.08, 0.0, 0.0], [0.0, 0.0, 0.0]],
[[62.76, 0.0, 0.0], [0.0, 155.28, -0.06], [0.0, -0.06, 28.53]],
[[0.0, 0.0, 0.0], [0.0, -0.06, 4.44], [0.0, 4.44, 0.0]],
],
[
[[0.0, 0.0, 4.23], [0.0, 0.0, 0.0], [4.23, 0.0, 0.0]],
[[0.0, 0.0, 0.0], [0.0, -0.06, 4.44], [0.0, 4.44, 0.0]],
[[30.18, 0.0, 0.0], [0.0, 28.53, 0.0], [0.0, 0.0, 207.57]],
],
])
self.structure = self.get_structure("BaNiO3")
ieee_file_path = os.path.join(PymatgenTest.TEST_FILES_DIR,
"ieee_conversion_data.json")
self.ones = Tensor(np.ones((3, 3)))
self.ieee_data = loadfn(ieee_file_path)
def test_new(self):
bad_2 = np.zeros((4, 4))
bad_3 = np.zeros((4, 4, 4))
self.assertRaises(ValueError, Tensor, bad_2)
self.assertRaises(ValueError, Tensor, bad_3)
self.assertEqual(self.rand_rank2.rank, 2)
self.assertEqual(self.rand_rank3.rank, 3)
self.assertEqual(self.rand_rank4.rank, 4)
def test_zeroed(self):
self.assertArrayEqual(
self.low_val.zeroed(),
Tensor([[0, 1 + 1e-5, 0], [1 + 1e-6, 0, 0], [0, 0, 1 + 1e-5]]),
)
self.assertArrayEqual(
self.low_val.zeroed(tol=1e-6),
Tensor([[1e-6, 1 + 1e-5, 1e-6], [1 + 1e-6, 1e-6, 1e-6],
[0, 0, 1 + 1e-5]]),
)
self.assertArrayEqual(
Tensor([[1e-6, -30, 1], [1e-7, 1, 0], [1e-8, 0, 1]]).zeroed(),
Tensor([[0, -30, 1], [0, 1, 0], [0, 0, 1]]),
)
def test_transform(self):
# Rank 3
tensor = Tensor(np.arange(0, 27).reshape(3, 3, 3))
symm_op = SymmOp.from_axis_angle_and_translation([0, 0, 1], 30, False,
[0, 0, 1])
new_tensor = tensor.transform(symm_op)
self.assertArrayAlmostEqual(
new_tensor,
[
[
[-0.871, -2.884, -1.928],
[-2.152, -6.665, -4.196],
[-1.026, -2.830, -1.572],
],
[
[0.044, 1.531, 1.804],
[4.263, 21.008, 17.928],
[5.170, 23.026, 18.722],
],
[
[1.679, 7.268, 5.821],
[9.268, 38.321, 29.919],
[8.285, 33.651, 26.000],
],
],
3,
)
def test_rotate(self):
self.assertArrayEqual(
self.vec.rotate([[0, -1, 0], [1, 0, 0], [0, 0, 1]]), [0, 1, 0])
self.assertArrayAlmostEqual(
self.non_symm.rotate(self.rotation),
SquareTensor([[0.531, 0.485, 0.271], [0.700, 0.5, 0.172],
[0.171, 0.233, 0.068]]),
decimal=3,
)
self.assertRaises(ValueError, self.non_symm.rotate, self.symm_rank2)
def test_einsum_sequence(self):
x = [1, 0, 0]
test = Tensor(np.arange(0, 3**4).reshape((3, 3, 3, 3)))
self.assertArrayAlmostEqual([0, 27, 54], test.einsum_sequence([x] * 3))
self.assertEqual(360, test.einsum_sequence([np.eye(3)] * 2))
self.assertRaises(ValueError, test.einsum_sequence,
Tensor(np.zeros(3)))
def test_symmetrized(self):
self.assertTrue(self.rand_rank2.symmetrized.is_symmetric())
self.assertTrue(self.rand_rank3.symmetrized.is_symmetric())
self.assertTrue(self.rand_rank4.symmetrized.is_symmetric())
def test_is_symmetric(self):
self.assertTrue(self.symm_rank2.is_symmetric())
self.assertTrue(self.symm_rank3.is_symmetric())
self.assertTrue(self.symm_rank4.is_symmetric())
tol_test = self.symm_rank4
tol_test[0, 1, 2, 2] += 1e-6
self.assertFalse(self.low_val.is_symmetric(tol=1e-8))
def test_fit_to_structure(self):
new_fit = self.unfit4.fit_to_structure(self.structure)
self.assertArrayAlmostEqual(new_fit, self.fit_r4, 1)
def test_is_fit_to_structure(self):
self.assertFalse(self.unfit4.is_fit_to_structure(self.structure))
self.assertTrue(self.fit_r3.is_fit_to_structure(self.structure))
self.assertTrue(self.fit_r4.is_fit_to_structure(self.structure))
def test_convert_to_ieee(self):
for entry in self.ieee_data:
xtal = entry["xtal"]
struct = entry["structure"]
orig = Tensor(entry["original_tensor"])
ieee = Tensor(entry["ieee_tensor"])
diff = np.max(abs(ieee - orig.convert_to_ieee(struct)))
err_msg = f"{xtal} IEEE conversion failed with max diff {diff}. Numpy version: {np.__version__}"
converted = orig.convert_to_ieee(struct, refine_rotation=False)
self.assertArrayAlmostEqual(ieee,
converted,
err_msg=err_msg,
decimal=3)
converted_refined = orig.convert_to_ieee(struct,
refine_rotation=True)
err_msg = "{} IEEE conversion with refinement failed with max diff {}. Numpy version: {}".format(
xtal, diff, np.__version__)
self.assertArrayAlmostEqual(ieee,
converted_refined,
err_msg=err_msg,
decimal=2)
def test_structure_transform(self):
# Test trivial case
trivial = self.fit_r4.structure_transform(self.structure,
self.structure.copy())
self.assertArrayAlmostEqual(trivial, self.fit_r4)
# Test simple rotation
rot_symm_op = SymmOp.from_axis_angle_and_translation([1, 1, 1], 55.5)
rot_struct = self.structure.copy()
rot_struct.apply_operation(rot_symm_op)
rot_tensor = self.fit_r4.rotate(rot_symm_op.rotation_matrix)
trans_tensor = self.fit_r4.structure_transform(self.structure,
rot_struct)
self.assertArrayAlmostEqual(rot_tensor, trans_tensor)
# Test supercell
bigcell = self.structure.copy()
bigcell.make_supercell([2, 2, 3])
trans_tensor = self.fit_r4.structure_transform(self.structure, bigcell)
self.assertArrayAlmostEqual(self.fit_r4, trans_tensor)
# Test rotated primitive to conventional for fcc structure
sn = self.get_structure("Sn")
sn_prim = SpacegroupAnalyzer(sn).get_primitive_standard_structure()
sn_prim.apply_operation(rot_symm_op)
rotated = self.fit_r4.rotate(rot_symm_op.rotation_matrix)
transformed = self.fit_r4.structure_transform(sn, sn_prim)
self.assertArrayAlmostEqual(rotated, transformed)
def test_from_voigt(self):
with self.assertRaises(ValueError):
Tensor.from_voigt([
[59.33, 28.08, 28.08, 0],
[28.08, 59.31, 28.07, 0],
[28.08, 28.07, 59.32, 0, 0],
[0, 0, 0, 26.35, 0],
[0, 0, 0, 0, 26.35],
])
# Rank 4
Tensor.from_voigt([
[59.33, 28.08, 28.08, 0, 0, 0],
[28.08, 59.31, 28.07, 0, 0, 0],
[28.08, 28.07, 59.32, 0, 0, 0],
[0, 0, 0, 26.35, 0, 0],
[0, 0, 0, 0, 26.35, 0],
[0, 0, 0, 0, 0, 26.35],
])
# Rank 3
Tensor.from_voigt(np.zeros((3, 6)))
# Rank 2
Tensor.from_voigt(np.zeros(6))
# Addresses occasional cast issues for integers
Tensor.from_voigt(np.arange(6))
def test_symmetry_reduce(self):
tbs = [Tensor.from_voigt(row) for row in np.eye(6) * 0.01]
reduced = symmetry_reduce(tbs, self.get_structure("Sn"))
self.assertEqual(len(reduced), 2)
self.assertArrayEqual([len(i) for i in reduced.values()], [2, 2])
reconstructed = []
for k, v in reduced.items():
reconstructed.extend([k.voigt] +
[k.transform(op).voigt for op in v])
reconstructed = sorted(reconstructed, key=lambda x: np.argmax(x))
self.assertArrayAlmostEqual([tb for tb in reconstructed],
np.eye(6) * 0.01)
def test_tensor_mapping(self):
# Test get
tbs = [Tensor.from_voigt(row) for row in np.eye(6) * 0.01]
reduced = symmetry_reduce(tbs, self.get_structure("Sn"))
tkey = Tensor.from_values_indices([0.01], [(0, 0)])
tval = reduced[tkey]
for tens_1, tens_2 in zip(tval, reduced[tbs[0]]):
self.assertAlmostEqual(tens_1, tens_2)
# Test set
reduced[tkey] = "test_val"
self.assertEqual(reduced[tkey], "test_val")
# Test empty initialization
empty = TensorMapping()
self.assertEqual(empty._tensor_list, [])
def test_populate(self):
test_data = loadfn(
os.path.join(PymatgenTest.TEST_FILES_DIR, "test_toec_data.json"))
sn = self.get_structure("Sn")
vtens = np.zeros((6, 6))
vtens[0, 0] = 259.31
vtens[0, 1] = 160.71
vtens[3, 3] = 73.48
et = Tensor.from_voigt(vtens)
populated = et.populate(sn, prec=1e-3).voigt.round(2)
self.assertAlmostEqual(populated[1, 1], 259.31)
self.assertAlmostEqual(populated[2, 2], 259.31)
self.assertAlmostEqual(populated[0, 2], 160.71)
self.assertAlmostEqual(populated[1, 2], 160.71)
self.assertAlmostEqual(populated[4, 4], 73.48)
self.assertAlmostEqual(populated[5, 5], 73.48)
# test a rank 6 example
vtens = np.zeros([6] * 3)
indices = [(0, 0, 0), (0, 0, 1), (0, 1, 2), (0, 3, 3), (0, 5, 5),
(3, 4, 5)]
values = [-1271.0, -814.0, -50.0, -3.0, -780.0, -95.0]
for v, idx in zip(values, indices):
vtens[idx] = v
toec = Tensor.from_voigt(vtens)
toec = toec.populate(sn, prec=1e-3, verbose=True)
self.assertAlmostEqual(toec.voigt[1, 1, 1], -1271)
self.assertAlmostEqual(toec.voigt[0, 1, 1], -814)
self.assertAlmostEqual(toec.voigt[0, 2, 2], -814)
self.assertAlmostEqual(toec.voigt[1, 4, 4], -3)
self.assertAlmostEqual(toec.voigt[2, 5, 5], -3)
self.assertAlmostEqual(toec.voigt[1, 2, 0], -50)
self.assertAlmostEqual(toec.voigt[4, 5, 3], -95)
et = Tensor.from_voigt(test_data["C3_raw"]).fit_to_structure(sn)
new = np.zeros(et.voigt.shape)
for idx in indices:
new[idx] = et.voigt[idx]
new = Tensor.from_voigt(new).populate(sn)
self.assertArrayAlmostEqual(new, et, decimal=2)
def test_from_values_indices(self):
sn = self.get_structure("Sn")
indices = [(0, 0), (0, 1), (3, 3)]
values = [259.31, 160.71, 73.48]
et = Tensor.from_values_indices(values,
indices,
structure=sn,
populate=True).voigt.round(4)
self.assertAlmostEqual(et[1, 1], 259.31)
self.assertAlmostEqual(et[2, 2], 259.31)
self.assertAlmostEqual(et[0, 2], 160.71)
self.assertAlmostEqual(et[1, 2], 160.71)
self.assertAlmostEqual(et[4, 4], 73.48)
self.assertAlmostEqual(et[5, 5], 73.48)
def test_serialization(self):
# Test base serialize-deserialize
d = self.symm_rank2.as_dict()
new = Tensor.from_dict(d)
self.assertArrayAlmostEqual(new, self.symm_rank2)
d = self.symm_rank3.as_dict(voigt=True)
new = Tensor.from_dict(d)
self.assertArrayAlmostEqual(new, self.symm_rank3)
def test_projection_methods(self):
self.assertAlmostEqual(self.rand_rank2.project([1, 0, 0]),
self.rand_rank2[0, 0])
self.assertAlmostEqual(self.rand_rank2.project([1, 1, 1]),
np.sum(self.rand_rank2) / 3)
# Test integration
self.assertArrayAlmostEqual(self.ones.average_over_unit_sphere(), 1)
def test_summary_methods(self):
self.assertEqual(
set(self.ones.get_grouped_indices()[0]),
set(itertools.product(range(3), range(3))),
)
self.assertEqual(
self.ones.get_grouped_indices(voigt=True)[0],
[(i, ) for i in range(6)])
self.assertEqual(self.ones.get_symbol_dict(), {"T_1": 1})
self.assertEqual(self.ones.get_symbol_dict(voigt=False), {"T_11": 1})
def test_round(self):
test = self.non_symm + 0.01
rounded = test.round(1)
self.assertArrayAlmostEqual(rounded, self.non_symm)
self.assertTrue(isinstance(rounded, Tensor))