def _get_ops_for_site(self, site_index):
cn = self.get_cn(site_index) # pylint:disable=invalid-name
try:
names = OP_DEF[cn]["names"]
is_open = OP_DEF[cn]["open"]
weights = OP_DEF[cn]["weights"]
lsop = LocalStructOrderParams(names)
return (
cn,
names,
lsop.get_order_parameters(self.structure, site_index),
is_open,
weights,
)
except KeyError:
# For a bit more fine grained error messages
if cn <= 3: # pylint:disable=no-else-raise
raise LowCoordinationNumber(
"Coordination number {} is low \
and order parameters undefined".format(
cn
)
)
elif cn > 8:
raise HighCoordinationNumber(
"Coordination number {} is high \
and order parameters undefined".format(
cn
)
)
return cn, None, None, None, None
def test_init(self):
self.assertIsNotNone(
LocalStructOrderParams(["cn"], parameters=None, cutoff=0.99))
parameters = [{'norm': 2}]
lostops = LocalStructOrderParams(["cn"], parameters=parameters)
tmp = lostops.get_parameters(0)
parameters[0]['norm'] = 3
self.assertEqual(tmp, lostops.get_parameters(0))
def test_init(self):
self.assertIsNotNone(
LocalStructOrderParams(["cn"], parameters=None, cutoff=0.99))
parameters = [{'norm': 2}]
lostops = LocalStructOrderParams(["cn"], parameters=parameters)
tmp = lostops.get_parameters(0)
parameters[0]['norm'] = 3
self.assertEqual(tmp, lostops.get_parameters(0))
def _get_local_order_parameters(structure_graph, n):
"""
A copy of the method in pymatgen.analysis.local_env which
can operate on StructureGraph directly.
Calculate those local structure order parameters for
the given site whose ideal CN corresponds to the
underlying motif (e.g., CN=4, then calculate the
square planar, tetrahedral, see-saw-like,
rectangular see-saw-like order paramters).
Args:
structure_graph: StructureGraph object
n (int): site index.
Returns (Dict[str, float]):
A dict of order parameters (values) and the
underlying motif type (keys; for example, tetrahedral).
"""
# TODO: move me to pymatgen once stable
# code from @nisse3000, moved here from graphs to avoid circular
# import, also makes sense to have this as a general NN method
cn = structure_graph.get_coordination_of_site(n)
if cn in [int(k_cn) for k_cn in cn_opt_params.keys()]:
names = [k for k in cn_opt_params[cn].keys()]
types = []
params = []
for name in names:
types.append(cn_opt_params[cn][name][0])
tmp = (
cn_opt_params[cn][name][1] if len(cn_opt_params[cn][name]) > 1 else None
)
params.append(tmp)
lostops = LocalStructOrderParams(types, parameters=params)
sites = [structure_graph.structure[n]] + [
connected_site.site
for connected_site in structure_graph.get_connected_sites(n)
]
lostop_vals = lostops.get_order_parameters(
sites, 0, indices_neighs=[i for i in range(1, cn + 1)]
)
d = {}
for i, lostop in enumerate(lostop_vals):
d[names[i]] = lostop
return d
else:
return None
def get_local_order_parameters(self, n):
"""
Calculate those local structure order parameters for
the given site whose ideal CN corresponds to the
underlying motif (e.g., CN=4, then calculate the
square planar, tetrahedral, see-saw-like,
rectangular see-saw-like order paramters).
Args:
n (integer): site index.
Returns:
A dict of order parameters (values) and the
underlying motif type (keys; for example, tetrahedral).
"""
cn = self.get_coordination_of_site(n)
if cn in [int(k_cn) for k_cn in cn_opt_params.keys()]:
names = [k for k in cn_opt_params[cn].keys()]
types = []
params = []
for name in names:
types.append(cn_opt_params[cn][name][0])
tmp = cn_opt_params[cn][name][1] \
if len(cn_opt_params[cn][name]) > 1 else None
params.append(tmp)
lostops = LocalStructOrderParams(types, parameters=params)
sites = [self.structure[n]]
for s in self.get_connected_sites(n):
sites.append(s.periodic_site)
lostop_vals = lostops.get_order_parameters(
sites, 0, indices_neighs=[i for i in range(1, cn+1)])
d = {}
for i, lostop in enumerate(lostop_vals):
d[names[i]] = lostop
return d
else:
return None
def __init__(self,
optypes,
override_cn1=True,
cutoff_radius=8,
tol=1E-2,
cation_anion=False):
"""
Initialize the CrystalSiteFingerprint. Use the from_preset() function to
use default params.
Args:
optypes (dict): a dict of coordination number (int) to a list of str
representing the order parameter types
override_cn1 (bool): whether to use a special function for the single
neighbor case. Suggest to keep True.
cutoff_radius (int): radius in Angstroms for neighbor finding
tol (float): numerical tolerance (in case your site distances are
not perfect or to correct for float tolerances)
cation_anion (bool): whether to only consider cation<->anion bonds
(bonds with zero charge are also allowed)
"""
self.optypes = copy.deepcopy(optypes)
self.override_cn1 = override_cn1
self.cutoff_radius = cutoff_radius
self.tol = tol
self.cation_anion = cation_anion
if self.override_cn1 and self.optypes.get(1) != ["wt"]:
raise ValueError(
"If override_cn1 is True, optypes[1] must be ['wt']!")
self.ops = {}
for cn, t_list in self.optypes.items():
self.ops[cn] = []
for t in t_list:
if t == "wt":
self.ops[cn].append(t)
else:
ot = t
p = None
if cn in cn_motif_op_params.keys():
if t in cn_motif_op_params[cn].keys():
ot = cn_motif_op_params[cn][t][0]
if len(cn_motif_op_params[cn][t]) > 1:
p = cn_motif_op_params[cn][t][1]
self.ops[cn].append(
LocalStructOrderParams([ot], parameters=[p]))
def get_analysis_and_structure(self,
structure,
calculate_valences=True,
guesstimate_spin=False,
op_threshold=0.1):
"""
Obtain an analysis of a given structure and if it may be Jahn-Teller
active or not. This is a heuristic, and may give false positives and
false negatives (false positives are preferred).
:param structure: input structure
:param calculate_valences (bool): whether to attempt to calculate valences or not, structure
should have oxidation states to perform analysis
:param guesstimate_spin (bool): whether to guesstimate spin state from magnetic moments
or not, use with caution
:param op_threshold (float): threshold for order parameter above which to consider site
to match an octahedral or tetrahedral motif, since Jahn-Teller structures can often be
quite distorted, this threshold is smaller than one might expect
:return (dict): analysis of structure, with key 'strength' which may be 'none', 'strong',
'weak', or 'unknown'
"""
structure = structure.get_primitive_structure()
if calculate_valences:
bva = BVAnalyzer()
structure = bva.get_oxi_state_decorated_structure(structure)
# no point testing multiple equivalent sites, doesn't make any difference to analysis
# but makes returned
symmetrized_structure = SpacegroupAnalyzer(
structure).get_symmetrized_structure()
# to detect structural motifs of a given site
op = LocalStructOrderParams(['oct', 'tet'])
# dict of site index to the Jahn-Teller analysis of that site
jt_sites = []
non_jt_sites = []
for indices in symmetrized_structure.equivalent_indices:
idx = indices[0]
site = symmetrized_structure[idx]
# only interested in sites with oxidation states
if isinstance(site.specie,
Specie) and site.specie.element.is_transition_metal:
# get motif around site
order_params = op.get_order_parameters(symmetrized_structure,
idx)
if order_params[0] > order_params[1] and order_params[
0] > op_threshold:
motif = 'oct'
motif_order_parameter = order_params[0]
elif order_params[1] > op_threshold:
motif = 'tet'
motif_order_parameter = order_params[1]
else:
motif = 'unknown'
motif_order_parameter = None
if motif == "oct" or motif == "tet":
# guess spin of metal ion
if guesstimate_spin and 'magmom' in site.properties:
# estimate if high spin or low spin
magmom = site.properties['magmom']
spin_state = self._estimate_spin_state(
site.specie, motif, magmom)
else:
spin_state = "unknown"
magnitude = self.get_magnitude_of_effect_from_species(
site.specie, spin_state, motif)
if magnitude != "none":
ligands = get_neighbors_of_site_with_index(
structure, idx, approach="min_dist", delta=0.15)
ligand_bond_lengths = [
ligand.distance(structure[idx])
for ligand in ligands
]
ligands_species = list(
set([str(ligand.specie) for ligand in ligands]))
ligand_bond_length_spread = max(ligand_bond_lengths) - \
min(ligand_bond_lengths)
def trim(f):
# avoid storing to unreasonable precision, hurts readability
return float("{:.4f}".format(f))
# to be Jahn-Teller active, all ligands have to be the same
if len(ligands_species) == 1:
jt_sites.append({
'strength':
magnitude,
'motif':
motif,
'motif_order_parameter':
trim(motif_order_parameter),
'spin_state':
spin_state,
'species':
str(site.specie),
'ligand':
ligands_species[0],
'ligand_bond_lengths': [
trim(length)
for length in ligand_bond_lengths
],
'ligand_bond_length_spread':
trim(ligand_bond_length_spread),
'site_indices':
indices
})
# store reasons for not being J-T active
else:
non_jt_sites.append({
'site_indices':
indices,
'strength':
"none",
'reason':
"Not Jahn-Teller active for this "
"electronic configuration."
})
else:
non_jt_sites.append({
'site_indices': indices,
'strength': "none",
'reason': "motif is {}".format(motif)
})
# perform aggregation of all sites
if jt_sites:
analysis = {'active': True}
# if any site could exhibit 'strong' Jahn-Teller effect
# then mark whole structure as strong
strong_magnitudes = [
site['strength'] == "strong" for site in jt_sites
]
if any(strong_magnitudes):
analysis['strength'] = "strong"
else:
analysis['strength'] = "weak"
analysis['sites'] = jt_sites
return analysis, structure
else:
return {'active': False, 'sites': non_jt_sites}, structure
def test_get_order_parameters(self):
# Set up everything.
op_types = ["cn", "bent", "bent", "tet", "oct", "bcc", "q2", "q4", \
"q6", "reg_tri", "sq", "sq_pyr_legacy", "tri_bipyr", "sgl_bd", \
"tri_plan", "sq_plan", "pent_plan", "sq_pyr", "tri_pyr", \
"pent_pyr", "hex_pyr", "pent_bipyr", "hex_bipyr", "T", "cuboct", \
"see_saw_rect", "hex_plan_max", "tet_max", "oct_max", "tri_plan_max", "sq_plan_max", \
"pent_plan_max", "cuboct_max", "tet_max"]
op_params = [None for i in range(len(op_types))]
op_params[1] = {'TA': 1, 'IGW_TA': 1. / 0.0667}
op_params[2] = {'TA': 45. / 180, 'IGW_TA': 1. / 0.0667}
op_params[33] = {
'TA': 0.6081734479693927,
'IGW_TA': 18.33,
"fac_AA": 1.5,
"exp_cos_AA": 2
}
ops_044 = LocalStructOrderParams(op_types,
parameters=op_params,
cutoff=0.44)
ops_071 = LocalStructOrderParams(op_types,
parameters=op_params,
cutoff=0.71)
ops_087 = LocalStructOrderParams(op_types,
parameters=op_params,
cutoff=0.87)
ops_099 = LocalStructOrderParams(op_types,
parameters=op_params,
cutoff=0.99)
ops_101 = LocalStructOrderParams(op_types,
parameters=op_params,
cutoff=1.01)
ops_501 = LocalStructOrderParams(op_types,
parameters=op_params,
cutoff=5.01)
ops_voro = LocalStructOrderParams(op_types, parameters=op_params)
# Single bond.
op_vals = ops_101.get_order_parameters(self.single_bond, 0)
self.assertAlmostEqual(int(op_vals[13] * 1000), 1000)
op_vals = ops_501.get_order_parameters(self.single_bond, 0)
self.assertAlmostEqual(int(op_vals[13] * 1000), 799)
op_vals = ops_101.get_order_parameters(self.linear, 0)
self.assertAlmostEqual(int(op_vals[13] * 1000), 0)
# Linear motif.
op_vals = ops_101.get_order_parameters(self.linear, 0)
self.assertAlmostEqual(int(op_vals[1] * 1000), 1000)
# 45 degrees-bent motif.
op_vals = ops_101.get_order_parameters(self.bent45, 0)
self.assertAlmostEqual(int(op_vals[2] * 1000), 1000)
# T-shape motif.
op_vals = ops_101.get_order_parameters(self.T_shape,
0,
indices_neighs=[1, 2, 3])
self.assertAlmostEqual(int(op_vals[23] * 1000), 1000)
# Cubic structure.
op_vals = ops_099.get_order_parameters(self.cubic, 0)
self.assertAlmostEqual(op_vals[0], 0.0)
self.assertIsNone(op_vals[3])
self.assertIsNone(op_vals[4])
self.assertIsNone(op_vals[5])
self.assertIsNone(op_vals[6])
self.assertIsNone(op_vals[7])
self.assertIsNone(op_vals[8])
op_vals = ops_101.get_order_parameters(self.cubic, 0)
self.assertAlmostEqual(op_vals[0], 6.0)
self.assertAlmostEqual(int(op_vals[3] * 1000), 23)
self.assertAlmostEqual(int(op_vals[4] * 1000), 1000)
self.assertAlmostEqual(int(op_vals[5] * 1000), 333)
self.assertAlmostEqual(int(op_vals[6] * 1000), 0)
self.assertAlmostEqual(int(op_vals[7] * 1000), 763)
self.assertAlmostEqual(int(op_vals[8] * 1000), 353)
self.assertAlmostEqual(int(op_vals[28] * 1000), 1000)
# Bcc structure.
op_vals = ops_087.get_order_parameters(self.bcc, 0)
self.assertAlmostEqual(op_vals[0], 8.0)
self.assertAlmostEqual(int(op_vals[3] * 1000), 200)
self.assertAlmostEqual(int(op_vals[4] * 1000), 145)
self.assertAlmostEqual(int(op_vals[5] * 1000 + 0.5), 1000)
self.assertAlmostEqual(int(op_vals[6] * 1000), 0)
self.assertAlmostEqual(int(op_vals[7] * 1000), 509)
self.assertAlmostEqual(int(op_vals[8] * 1000), 628)
# Fcc structure.
op_vals = ops_071.get_order_parameters(self.fcc, 0)
self.assertAlmostEqual(op_vals[0], 12.0)
self.assertAlmostEqual(int(op_vals[3] * 1000), 36)
self.assertAlmostEqual(int(op_vals[4] * 1000), 78)
self.assertAlmostEqual(int(op_vals[5] * 1000), -2)
self.assertAlmostEqual(int(op_vals[6] * 1000), 0)
self.assertAlmostEqual(int(op_vals[7] * 1000), 190)
self.assertAlmostEqual(int(op_vals[8] * 1000), 574)
# Hcp structure.
op_vals = ops_101.get_order_parameters(self.hcp, 0)
self.assertAlmostEqual(op_vals[0], 12.0)
self.assertAlmostEqual(int(op_vals[3] * 1000), 33)
self.assertAlmostEqual(int(op_vals[4] * 1000), 82)
self.assertAlmostEqual(int(op_vals[5] * 1000), -26)
self.assertAlmostEqual(int(op_vals[6] * 1000), 0)
self.assertAlmostEqual(int(op_vals[7] * 1000), 97)
self.assertAlmostEqual(int(op_vals[8] * 1000), 484)
# Diamond structure.
op_vals = ops_044.get_order_parameters(self.diamond, 0)
self.assertAlmostEqual(op_vals[0], 4.0)
self.assertAlmostEqual(int(op_vals[3] * 1000), 1000)
self.assertAlmostEqual(int(op_vals[4] * 1000), 37)
self.assertAlmostEqual(op_vals[5], 0.75)
self.assertAlmostEqual(int(op_vals[6] * 1000), 0)
self.assertAlmostEqual(int(op_vals[7] * 1000), 509)
self.assertAlmostEqual(int(op_vals[8] * 1000), 628)
self.assertAlmostEqual(int(op_vals[27] * 1000), 1000)
# Trigonal off-plane molecule.
op_vals = ops_044.get_order_parameters(self.trigonal_off_plane, 0)
self.assertAlmostEqual(op_vals[0], 3.0)
self.assertAlmostEqual(int(op_vals[3] * 1000), 1000)
self.assertAlmostEqual(int(op_vals[33] * 1000), 1000)
# Trigonal-planar motif.
op_vals = ops_101.get_order_parameters(self.trigonal_planar, 0)
self.assertEqual(int(op_vals[0] + 0.5), 3)
self.assertAlmostEqual(int(op_vals[14] * 1000 + 0.5), 1000)
self.assertAlmostEqual(int(op_vals[29] * 1000 + 0.5), 1000)
# Regular triangle motif.
op_vals = ops_101.get_order_parameters(self.regular_triangle, 0)
self.assertAlmostEqual(int(op_vals[9] * 1000), 999)
# Square-planar motif.
op_vals = ops_101.get_order_parameters(self.square_planar, 0)
self.assertAlmostEqual(int(op_vals[15] * 1000 + 0.5), 1000)
self.assertAlmostEqual(int(op_vals[30] * 1000 + 0.5), 1000)
# Square motif.
op_vals = ops_101.get_order_parameters(self.square, 0)
self.assertAlmostEqual(int(op_vals[10] * 1000), 1000)
# Pentagonal planar.
op_vals = ops_101.get_order_parameters(self.pentagonal_planar.sites,
0,
indices_neighs=[1, 2, 3, 4, 5])
self.assertAlmostEqual(int(op_vals[12] * 1000 + 0.5), 126)
self.assertAlmostEqual(int(op_vals[16] * 1000 + 0.5), 1000)
self.assertAlmostEqual(int(op_vals[31] * 1000 + 0.5), 1000)
# Trigonal pyramid motif.
op_vals = ops_101.get_order_parameters(self.trigonal_pyramid,
0,
indices_neighs=[1, 2, 3, 4])
self.assertAlmostEqual(int(op_vals[18] * 1000 + 0.5), 1000)
# Square pyramid motif.
op_vals = ops_101.get_order_parameters(self.square_pyramid, 0)
self.assertAlmostEqual(int(op_vals[11] * 1000 + 0.5), 1000)
self.assertAlmostEqual(int(op_vals[12] * 1000 + 0.5), 667)
self.assertAlmostEqual(int(op_vals[17] * 1000 + 0.5), 1000)
# Pentagonal pyramid motif.
op_vals = ops_101.get_order_parameters(
self.pentagonal_pyramid, 0, indices_neighs=[1, 2, 3, 4, 5, 6])
self.assertAlmostEqual(int(op_vals[19] * 1000 + 0.5), 1000)
# Hexagonal pyramid motif.
op_vals = ops_101.get_order_parameters(
self.hexagonal_pyramid, 0, indices_neighs=[1, 2, 3, 4, 5, 6, 7])
self.assertAlmostEqual(int(op_vals[20] * 1000 + 0.5), 1000)
# Trigonal bipyramidal.
op_vals = ops_101.get_order_parameters(self.trigonal_bipyramidal.sites,
0,
indices_neighs=[1, 2, 3, 4, 5])
self.assertAlmostEqual(int(op_vals[12] * 1000 + 0.5), 1000)
# Pentagonal bipyramidal.
op_vals = ops_101.get_order_parameters(
self.pentagonal_bipyramid.sites,
0,
indices_neighs=[1, 2, 3, 4, 5, 6, 7])
self.assertAlmostEqual(int(op_vals[21] * 1000 + 0.5), 1000)
# Hexagonal bipyramid motif.
op_vals = ops_101.get_order_parameters(
self.hexagonal_bipyramid,
0,
indices_neighs=[1, 2, 3, 4, 5, 6, 7, 8])
self.assertAlmostEqual(int(op_vals[22] * 1000 + 0.5), 1000)
# Cuboctahedral motif.
op_vals = ops_101.get_order_parameters(
self.cuboctahedron, 0, indices_neighs=[i for i in range(1, 13)])
self.assertAlmostEqual(int(op_vals[24] * 1000 + 0.5), 1000)
self.assertAlmostEqual(int(op_vals[32] * 1000 + 0.5), 1000)
# See-saw motif.
op_vals = ops_101.get_order_parameters(
self.see_saw_rect, 0, indices_neighs=[i for i in range(1, 5)])
self.assertAlmostEqual(int(op_vals[25] * 1000 + 0.5), 1000)
# Hexagonal planar motif.
op_vals = ops_101.get_order_parameters(
self.hexagonal_planar, 0, indices_neighs=[1, 2, 3, 4, 5, 6])
self.assertAlmostEqual(int(op_vals[26] * 1000 + 0.5), 1000)
# Test providing explicit neighbor lists.
op_vals = ops_101.get_order_parameters(self.bcc, 0, indices_neighs=[1])
self.assertIsNotNone(op_vals[0])
self.assertIsNone(op_vals[3])
with self.assertRaises(ValueError):
ops_101.get_order_parameters(self.bcc, 0, indices_neighs=[2])
def test_init(self):
self.assertIsNotNone(
LocalStructOrderParams(["cn"], parameters=None, cutoff=0.99))
def get_analysis_and_structure(self,
structure,
calculate_valences=True,
guesstimate_spin=False,
op_threshold=0.1):
"""
Obtain an analysis of a given structure and if it may be Jahn-Teller
active or not. This is a heuristic, and may give false positives and
false negatives (false positives are preferred).
:param structure: input structure
:param calculate_valences (bool): whether to attempt to calculate valences or not, structure
should have oxidation states to perform analysis
:param guesstimate_spin (bool): whether to guesstimate spin state from magnetic moments
or not, use with caution
:param op_threshold (float): threshold for order parameter above which to consider site
to match an octahedral or tetrahedral motif, since Jahn-Teller structures can often be
quite distorted, this threshold is smaller than one might expect
:return (dict): analysis of structure, with key 'strength' which may be 'none', 'strong',
'weak', or 'unknown'
"""
structure = structure.get_primitive_structure()
if calculate_valences:
bva = BVAnalyzer()
structure = bva.get_oxi_state_decorated_structure(structure)
# no point testing multiple equivalent sites, doesn't make any difference to analysis
# but makes returned
symmetrized_structure = SpacegroupAnalyzer(structure).get_symmetrized_structure()
# to detect structural motifs of a given site
op = LocalStructOrderParams(['oct', 'tet'])
# dict of site index to the Jahn-Teller analysis of that site
jt_sites = []
non_jt_sites = []
for indices in symmetrized_structure.equivalent_indices:
idx = indices[0]
site = symmetrized_structure[idx]
# only interested in sites with oxidation states
if isinstance(site.specie, Specie) and site.specie.element.is_transition_metal:
# get motif around site
order_params = op.get_order_parameters(symmetrized_structure, idx)
if order_params[0] > order_params[1] and order_params[0] > op_threshold:
motif = 'oct'
motif_order_parameter = order_params[0]
elif order_params[1] > op_threshold:
motif = 'tet'
motif_order_parameter = order_params[1]
else:
motif = 'unknown'
motif_order_parameter = None
if motif == "oct" or motif == "tet":
# guess spin of metal ion
if guesstimate_spin and 'magmom' in site.properties:
# estimate if high spin or low spin
magmom = site.properties['magmom']
spin_state = self._estimate_spin_state(site.specie, motif, magmom)
else:
spin_state = "unknown"
magnitude = self.get_magnitude_of_effect_from_species(site.specie,
spin_state,
motif)
if magnitude != "none":
ligands = get_neighbors_of_site_with_index(structure, idx,
approach="min_dist",
delta=0.15)
ligand_bond_lengths = [ligand.distance(structure[idx])
for ligand in ligands]
ligands_species = list(set([str(ligand.specie) for ligand in ligands]))
ligand_bond_length_spread = max(ligand_bond_lengths) - \
min(ligand_bond_lengths)
def trim(f):
# avoid storing to unreasonable precision, hurts readability
return float("{:.4f}".format(f))
# to be Jahn-Teller active, all ligands have to be the same
if len(ligands_species) == 1:
jt_sites.append({'strength': magnitude,
'motif': motif,
'motif_order_parameter': trim(motif_order_parameter),
'spin_state': spin_state,
'species': str(site.specie),
'ligand': ligands_species[0],
'ligand_bond_lengths': [trim(length) for length in
ligand_bond_lengths],
'ligand_bond_length_spread':
trim(ligand_bond_length_spread),
'site_indices': indices})
# store reasons for not being J-T active
else:
non_jt_sites.append({'site_indices': indices,
'strength': "none",
'reason': "Not Jahn-Teller active for this "
"electronic configuration."})
else:
non_jt_sites.append({'site_indices': indices,
'strength': "none",
'reason': "motif is {}".format(motif)})
# perform aggregation of all sites
if jt_sites:
analysis = {'active': True}
# if any site could exhibit 'strong' Jahn-Teller effect
# then mark whole structure as strong
strong_magnitudes = [site['strength'] == "strong" for site in jt_sites]
if any(strong_magnitudes):
analysis['strength'] = "strong"
else:
analysis['strength'] = "weak"
analysis['sites'] = jt_sites
return analysis, structure
else:
return {'active': False, 'sites': non_jt_sites}, structure
def test_get_order_parameters(self):
# Set up everything.
op_types = ["cn", "bent", "bent", "tet", "oct", "bcc", "q2", "q4", \
"q6", "reg_tri", "sq", "sq_pyr_legacy", "tri_bipyr", "sgl_bd", \
"tri_plan", "sq_plan", "pent_plan", "sq_pyr", "tri_pyr", \
"pent_pyr", "hex_pyr", "pent_bipyr", "hex_bipyr", "T", "cuboct", \
"see_saw_rect", "hex_plan_max", "tet_max", "oct_max", "tri_plan_max", "sq_plan_max", \
"pent_plan_max", "cuboct_max", "tet_max"]
op_params = [None for i in range(len(op_types))]
op_params[1] = {'TA': 1, 'IGW_TA': 1./0.0667}
op_params[2] = {'TA': 45./180, 'IGW_TA': 1./0.0667}
op_params[33] = {'TA': 0.6081734479693927, 'IGW_TA': 18.33, "fac_AA": 1.5, "exp_cos_AA": 2}
ops_044 = LocalStructOrderParams(op_types, parameters=op_params, cutoff=0.44)
ops_071 = LocalStructOrderParams(op_types, parameters=op_params, cutoff=0.71)
ops_087 = LocalStructOrderParams(op_types, parameters=op_params, cutoff=0.87)
ops_099 = LocalStructOrderParams(op_types, parameters=op_params, cutoff=0.99)
ops_101 = LocalStructOrderParams(op_types, parameters=op_params, cutoff=1.01)
ops_501 = LocalStructOrderParams(op_types, parameters=op_params, cutoff=5.01)
ops_voro = LocalStructOrderParams(op_types, parameters=op_params)
# Single bond.
op_vals = ops_101.get_order_parameters(self.single_bond, 0)
self.assertAlmostEqual(int(op_vals[13] * 1000), 1000)
op_vals = ops_501.get_order_parameters(self.single_bond, 0)
self.assertAlmostEqual(int(op_vals[13] * 1000), 799)
op_vals = ops_101.get_order_parameters(self.linear, 0)
self.assertAlmostEqual(int(op_vals[13] * 1000), 0)
# Linear motif.
op_vals = ops_101.get_order_parameters(self.linear, 0)
self.assertAlmostEqual(int(op_vals[1] * 1000), 1000)
# 45 degrees-bent motif.
op_vals = ops_101.get_order_parameters(self.bent45, 0)
self.assertAlmostEqual(int(op_vals[2] * 1000), 1000)
# T-shape motif.
op_vals = ops_101.get_order_parameters(
self.T_shape, 0, indices_neighs=[1,2,3])
self.assertAlmostEqual(int(op_vals[23] * 1000), 1000)
# Cubic structure.
op_vals = ops_099.get_order_parameters(self.cubic, 0)
self.assertAlmostEqual(op_vals[0], 0.0)
self.assertIsNone(op_vals[3])
self.assertIsNone(op_vals[4])
self.assertIsNone(op_vals[5])
self.assertIsNone(op_vals[6])
self.assertIsNone(op_vals[7])
self.assertIsNone(op_vals[8])
op_vals = ops_101.get_order_parameters(self.cubic, 0)
self.assertAlmostEqual(op_vals[0], 6.0)
self.assertAlmostEqual(int(op_vals[3] * 1000), 23)
self.assertAlmostEqual(int(op_vals[4] * 1000), 1000)
self.assertAlmostEqual(int(op_vals[5] * 1000), 333)
self.assertAlmostEqual(int(op_vals[6] * 1000), 0)
self.assertAlmostEqual(int(op_vals[7] * 1000), 763)
self.assertAlmostEqual(int(op_vals[8] * 1000), 353)
self.assertAlmostEqual(int(op_vals[28] * 1000), 1000)
# Bcc structure.
op_vals = ops_087.get_order_parameters(self.bcc, 0)
self.assertAlmostEqual(op_vals[0], 8.0)
self.assertAlmostEqual(int(op_vals[3] * 1000), 200)
self.assertAlmostEqual(int(op_vals[4] * 1000), 145)
self.assertAlmostEqual(int(op_vals[5] * 1000 + 0.5), 1000)
self.assertAlmostEqual(int(op_vals[6] * 1000), 0)
self.assertAlmostEqual(int(op_vals[7] * 1000), 509)
self.assertAlmostEqual(int(op_vals[8] * 1000), 628)
# Fcc structure.
op_vals = ops_071.get_order_parameters(self.fcc, 0)
self.assertAlmostEqual(op_vals[0], 12.0)
self.assertAlmostEqual(int(op_vals[3] * 1000), 36)
self.assertAlmostEqual(int(op_vals[4] * 1000), 78)
self.assertAlmostEqual(int(op_vals[5] * 1000), -2)
self.assertAlmostEqual(int(op_vals[6] * 1000), 0)
self.assertAlmostEqual(int(op_vals[7] * 1000), 190)
self.assertAlmostEqual(int(op_vals[8] * 1000), 574)
# Hcp structure.
op_vals = ops_101.get_order_parameters(self.hcp, 0)
self.assertAlmostEqual(op_vals[0], 12.0)
self.assertAlmostEqual(int(op_vals[3] * 1000), 33)
self.assertAlmostEqual(int(op_vals[4] * 1000), 82)
self.assertAlmostEqual(int(op_vals[5] * 1000), -26)
self.assertAlmostEqual(int(op_vals[6] * 1000), 0)
self.assertAlmostEqual(int(op_vals[7] * 1000), 97)
self.assertAlmostEqual(int(op_vals[8] * 1000), 484)
# Diamond structure.
op_vals = ops_044.get_order_parameters(self.diamond, 0)
self.assertAlmostEqual(op_vals[0], 4.0)
self.assertAlmostEqual(int(op_vals[3] * 1000), 1000)
self.assertAlmostEqual(int(op_vals[4] * 1000), 37)
self.assertAlmostEqual(op_vals[5], 0.75)
self.assertAlmostEqual(int(op_vals[6] * 1000), 0)
self.assertAlmostEqual(int(op_vals[7] * 1000), 509)
self.assertAlmostEqual(int(op_vals[8] * 1000), 628)
self.assertAlmostEqual(int(op_vals[27] * 1000), 1000)
# Trigonal off-plane molecule.
op_vals = ops_044.get_order_parameters(self.trigonal_off_plane, 0)
self.assertAlmostEqual(op_vals[0], 3.0)
self.assertAlmostEqual(int(op_vals[3] * 1000), 1000)
self.assertAlmostEqual(int(op_vals[33] * 1000), 1000)
# Trigonal-planar motif.
op_vals = ops_101.get_order_parameters(self.trigonal_planar, 0)
self.assertEqual(int(op_vals[0] + 0.5), 3)
self.assertAlmostEqual(int(op_vals[14] * 1000 + 0.5), 1000)
self.assertAlmostEqual(int(op_vals[29] * 1000 + 0.5), 1000)
# Regular triangle motif.
op_vals = ops_101.get_order_parameters(self.regular_triangle, 0)
self.assertAlmostEqual(int(op_vals[9] * 1000), 999)
# Square-planar motif.
op_vals = ops_101.get_order_parameters(self.square_planar, 0)
self.assertAlmostEqual(int(op_vals[15] * 1000 + 0.5), 1000)
self.assertAlmostEqual(int(op_vals[30] * 1000 + 0.5), 1000)
# Square motif.
op_vals = ops_101.get_order_parameters(self.square, 0)
self.assertAlmostEqual(int(op_vals[10] * 1000), 1000)
# Pentagonal planar.
op_vals = ops_101.get_order_parameters(
self.pentagonal_planar.sites, 0, indices_neighs=[1,2,3,4,5])
self.assertAlmostEqual(int(op_vals[12] * 1000 + 0.5), 126)
self.assertAlmostEqual(int(op_vals[16] * 1000 + 0.5), 1000)
self.assertAlmostEqual(int(op_vals[31] * 1000 + 0.5), 1000)
# Trigonal pyramid motif.
op_vals = ops_101.get_order_parameters(
self.trigonal_pyramid, 0, indices_neighs=[1,2,3,4])
self.assertAlmostEqual(int(op_vals[18] * 1000 + 0.5), 1000)
# Square pyramid motif.
op_vals = ops_101.get_order_parameters(self.square_pyramid, 0)
self.assertAlmostEqual(int(op_vals[11] * 1000 + 0.5), 1000)
self.assertAlmostEqual(int(op_vals[12] * 1000 + 0.5), 667)
self.assertAlmostEqual(int(op_vals[17] * 1000 + 0.5), 1000)
# Pentagonal pyramid motif.
op_vals = ops_101.get_order_parameters(
self.pentagonal_pyramid, 0, indices_neighs=[1,2,3,4,5,6])
self.assertAlmostEqual(int(op_vals[19] * 1000 + 0.5), 1000)
# Hexagonal pyramid motif.
op_vals = ops_101.get_order_parameters(
self.hexagonal_pyramid, 0, indices_neighs=[1,2,3,4,5,6,7])
self.assertAlmostEqual(int(op_vals[20] * 1000 + 0.5), 1000)
# Trigonal bipyramidal.
op_vals = ops_101.get_order_parameters(
self.trigonal_bipyramidal.sites, 0, indices_neighs=[1,2,3,4,5])
self.assertAlmostEqual(int(op_vals[12] * 1000 + 0.5), 1000)
# Pentagonal bipyramidal.
op_vals = ops_101.get_order_parameters(
self.pentagonal_bipyramid.sites, 0,
indices_neighs=[1,2,3,4,5,6,7])
self.assertAlmostEqual(int(op_vals[21] * 1000 + 0.5), 1000)
# Hexagonal bipyramid motif.
op_vals = ops_101.get_order_parameters(
self.hexagonal_bipyramid, 0, indices_neighs=[1,2,3,4,5,6,7,8])
self.assertAlmostEqual(int(op_vals[22] * 1000 + 0.5), 1000)
# Cuboctahedral motif.
op_vals = ops_101.get_order_parameters(
self.cuboctahedron, 0, indices_neighs=[i for i in range(1, 13)])
self.assertAlmostEqual(int(op_vals[24] * 1000 + 0.5), 1000)
self.assertAlmostEqual(int(op_vals[32] * 1000 + 0.5), 1000)
# See-saw motif.
op_vals = ops_101.get_order_parameters(
self.see_saw_rect, 0, indices_neighs=[i for i in range(1, 5)])
self.assertAlmostEqual(int(op_vals[25] * 1000 + 0.5), 1000)
# Hexagonal planar motif.
op_vals = ops_101.get_order_parameters(
self.hexagonal_planar, 0, indices_neighs=[1,2,3,4,5,6])
self.assertAlmostEqual(int(op_vals[26] * 1000 + 0.5), 1000)
# Test providing explicit neighbor lists.
op_vals = ops_101.get_order_parameters(self.bcc, 0, indices_neighs=[1])
self.assertIsNotNone(op_vals[0])
self.assertIsNone(op_vals[3])
with self.assertRaises(ValueError):
ops_101.get_order_parameters(self.bcc, 0, indices_neighs=[2])
thresh = None
from pymatgen.analysis.local_env import LocalStructOrderParams, get_neighbors_of_site_with_index
# +
if thresh is None:
thresh = {
"qtet": 0.5,
"qoct": 0.5,
"qbcc": 0.5,
"q6": 0.4,
"qtribipyr": 0.8,
"qsqpyr": 0.8
}
ops = LocalStructOrderParams(
["cn", "tet", "oct", "bcc", "q6", "sq_pyr", "tri_bipyr"])
neighs_cent = get_neighbors_of_site_with_index(struct,
n,
approach=approach,
delta=delta,
cutoff=cutoff)
neighs_cent.append(struct.sites[n])
opvals = ops.get_order_parameters(
neighs_cent,
len(neighs_cent) - 1,
indices_neighs=[i for i in range(len(neighs_cent) - 1)])
cn = int(opvals[0] + 0.5)
motif_type = "unrecognized"
nmotif = 0
def calculate_sites_order_values(molecule,
site_idxs,
target_species_type=None,
neigh_idxs=None):
"""
Calculate order parameters around metal centres.
Parameters
----------
molecule : :class:`pmg.Molecule` or :class:`pmg.Structure`
Pymatgen (pmg) molecule/structure to analyse.
site_idxs : :class:`list` of :class:`int`
Atom ids of sites to calculate OP of.
target_species_type : :class:`str`
Target neighbour element to use in OP calculation.
Defaults to :class:`NoneType` if no target species is known.
neigh_idxs : :class:`list` of :class:`list` of :class:`int`
Neighbours of each atom in site_idx. Ordering is important.
Defaults to :class:`NoneType` for when using
:class:`pmg.Structure` - i.e. a structure with a lattice.
Returns
-------
results : :class:`dict`
Dictionary of format
site_idx: dict of order parameters
{
`oct`: :class:`float`,
`sq_plan`: :class:`float`,
`q2`: :class:`float`,
`q4`: :class:`float`,
`q6`: :class:`float`
}.
"""
results = {}
if target_species_type is None:
targ_species = None
else:
targ_species = Specie(target_species_type)
# Define local order parameters class based on desired types.
types = [
'oct', # Octahedra OP.
'sq_plan', # Square planar envs.
'q2', # l=2 Steinhardt OP.
'q4', # l=4 Steinhardt OP.
'q6', # l=6 Steinhardt OP.
]
loc_ops = LocalStructOrderParams(types=types, )
if neigh_idxs is None:
for site in site_idxs:
site_results = loc_ops.get_order_parameters(
structure=molecule, n=site, target_spec=[targ_species])
results[site] = {i: j for i, j in zip(types, site_results)}
else:
for site, neigh in zip(site_idxs, neigh_idxs):
site_results = loc_ops.get_order_parameters(
structure=molecule,
n=site,
indices_neighs=neigh,
target_spec=targ_species)
results[site] = {i: j for i, j in zip(types, site_results)}
return results
def get_analysis_and_structure(
self,
structure: Structure,
calculate_valences: bool = True,
guesstimate_spin: bool = False,
op_threshold: float = 0.1,
) -> Tuple[Dict, Structure]:
"""Obtain an analysis of a given structure and if it may be Jahn-Teller
active or not. This is a heuristic, and may give false positives and
false negatives (false positives are preferred).
Args:
structure: input structure
calculate_valences: whether to attempt to calculate valences or not, structure
should have oxidation states to perform analysis (Default value = True)
guesstimate_spin: whether to guesstimate spin state from magnetic moments
or not, use with caution (Default value = False)
op_threshold: threshold for order parameter above which to consider site
to match an octahedral or tetrahedral motif, since Jahn-Teller structures
can often be
quite distorted, this threshold is smaller than one might expect
Returns:
analysis of structure, with key 'strength' which may be 'none', 'strong',
'weak', or 'unknown' (Default value = 0.1) and decorated structure
"""
structure = structure.get_primitive_structure()
if calculate_valences:
bva = BVAnalyzer()
structure = bva.get_oxi_state_decorated_structure(structure)
# no point testing multiple equivalent sites, doesn't make any difference to analysis
# but makes returned
symmetrized_structure = SpacegroupAnalyzer(
structure).get_symmetrized_structure()
# to detect structural motifs of a given site
op = LocalStructOrderParams(["oct", "tet"])
# dict of site index to the Jahn-Teller analysis of that site
jt_sites = []
non_jt_sites = []
for indices in symmetrized_structure.equivalent_indices:
idx = indices[0]
site = symmetrized_structure[idx]
# only interested in sites with oxidation states
if isinstance(site.specie,
Species) and site.specie.element.is_transition_metal:
# get motif around site
order_params = op.get_order_parameters(symmetrized_structure,
idx)
if order_params[0] > order_params[1] and order_params[
0] > op_threshold:
motif = "oct"
motif_order_parameter = order_params[0]
elif order_params[1] > op_threshold:
motif = "tet"
motif_order_parameter = order_params[1]
else:
motif = "unknown"
motif_order_parameter = None
if motif in ["oct", "tet"]:
motif = cast(Literal["oct", "tet"],
motif) # mypy needs help
# guess spin of metal ion
if guesstimate_spin and "magmom" in site.properties:
# estimate if high spin or low spin
magmom = site.properties["magmom"]
spin_state = self._estimate_spin_state(
site.specie, motif, magmom)
else:
spin_state = "unknown"
magnitude = self.get_magnitude_of_effect_from_species(
site.specie, spin_state, motif)
if magnitude != "none":
ligands = get_neighbors_of_site_with_index(
structure, idx, approach="min_dist", delta=0.15)
ligand_bond_lengths = [
ligand.distance(structure[idx])
for ligand in ligands
]
ligands_species = list(
{str(ligand.specie)
for ligand in ligands})
ligand_bond_length_spread = max(
ligand_bond_lengths) - min(ligand_bond_lengths)
def trim(f):
"""
Avoid storing to unreasonable precision, hurts readability.
"""
return float(f"{f:.4f}")
# to be Jahn-Teller active, all ligands have to be the same
if len(ligands_species) == 1:
jt_sites.append({
"strength":
magnitude,
"motif":
motif,
"motif_order_parameter":
trim(motif_order_parameter),
"spin_state":
spin_state,
"species":
str(site.specie),
"ligand":
ligands_species[0],
"ligand_bond_lengths": [
trim(length)
for length in ligand_bond_lengths
],
"ligand_bond_length_spread":
trim(ligand_bond_length_spread),
"site_indices":
indices,
})
# store reasons for not being J-T active
else:
non_jt_sites.append({
"site_indices":
indices,
"strength":
"none",
"reason":
"Not Jahn-Teller active for this electronic configuration.",
})
else:
non_jt_sites.append({
"site_indices": indices,
"strength": "none",
"reason": f"motif is {motif}",
})
# perform aggregation of all sites
if jt_sites:
analysis = {"active": True} # type: Dict[str, Any]
# if any site could exhibit 'strong' Jahn-Teller effect
# then mark whole structure as strong
strong_magnitudes = [
site["strength"] == "strong" for site in jt_sites
]
if any(strong_magnitudes):
analysis["strength"] = "strong"
else:
analysis["strength"] = "weak"
analysis["sites"] = jt_sites
return analysis, structure
return {"active": False, "sites": non_jt_sites}, structure
def site_is_of_motif_type(struct,
n,
neighbors_list=None,
approach="min_dist",
delta=0.1,
cutoff=10.0,
thresh=None):
"""
Returns the motif type of the site with index n in structure struct;
currently featuring "tetrahedral", "octahedral", "bcc", and "cp"
(close-packed: fcc and hcp) as well as "square pyramidal" and
"trigonal bipyramidal". If the site is not recognized,
"unrecognized" is returned. If a site should be assigned to two
different motifs, "multiple assignments" is returned.
Args:
struct (Structure): input structure.
n (int): index of site in Structure object for which motif type
is to be determined.
approach (str): type of neighbor-finding approach, where
"min_dist" will use the MinimumDistanceNN class,
"voronoi" the VoronoiNN class, "min_OKeeffe" the
MinimumOKeeffe class, and "min_VIRE" the MinimumVIRENN class.
delta (float): tolerance involved in neighbor finding.
cutoff (float): (large) radius to find tentative neighbors.
thresh (dict): thresholds for motif criteria (currently, required
keys and their default values are "qtet": 0.5,
"qoct": 0.5, "qbcc": 0.5, "q6": 0.4).
Returns: motif type (str).
"""
# | - site_is_of_motif_type
# print("THIS IS MY CUSTOM METHOD, NOT NATIVE PYMATGEN")
if thresh is None:
thresh = {
"qtet": 0.5,
"qoct": 0.5,
"qbcc": 0.5,
"q6": 0.4,
"qtribipyr": 0.8,
"qsqpyr": 0.8
}
ops = LocalStructOrderParams(
["cn", "tet", "oct", "bcc", "q6", "sq_pyr", "tri_bipyr"])
# #########################################################################
if neighbors_list is None:
neighs_cent = get_neighbors_of_site_with_index(struct,
n,
approach=approach,
delta=delta,
cutoff=cutoff)
else:
neighs_cent = neighbors_list
neighs_cent.append(struct.sites[n])
opvals = ops.get_order_parameters(
neighs_cent,
len(neighs_cent) - 1,
indices_neighs=[i for i in range(len(neighs_cent) - 1)])
cn = int(opvals[0] + 0.5)
motif_type = "unrecognized"
nmotif = 0
if cn == 4 and opvals[1] > thresh["qtet"]:
motif_type = "tetrahedral"
nmotif += 1
if cn == 5 and opvals[5] > thresh["qsqpyr"]:
motif_type = "square pyramidal"
nmotif += 1
if cn == 5 and opvals[6] > thresh["qtribipyr"]:
motif_type = "trigonal bipyramidal"
nmotif += 1
if cn == 6 and opvals[2] > thresh["qoct"]:
motif_type = "octahedral"
nmotif += 1
if cn == 8 and (opvals[3] > thresh["qbcc"] and opvals[1] < thresh["qtet"]):
motif_type = "bcc"
nmotif += 1
if cn == 12 and (opvals[4] > thresh["q6"] and opvals[1] < thresh["q6"] and
opvals[2] < thresh["q6"] and opvals[3] < thresh["q6"]):
motif_type = "cp"
nmotif += 1
if nmotif > 1:
motif_type = "multiple assignments"
return motif_type