def get_symmetry(mol, already_oriented=False):
'''
Return a list of SymmOps for a molecule's point symmetry
already_oriented: whether or not the principle axes of mol are already reoriented
'''
pga = PointGroupAnalyzer(mol)
#Handle linear molecules
if '*' in pga.sch_symbol:
if already_oriented == False:
#Reorient the molecule
oriented_mol, P = reoriented_molecule(mol)
pga = PointGroupAnalyzer(oriented_mol)
pg = pga.get_pointgroup()
symm_m = []
for op in pg:
symm_m.append(op)
#Add 12-fold and reflections in place of ininitesimal rotation
for axis in [[1, 0, 0], [0, 1, 0], [0, 0, 1]]:
op = SymmOp.from_rotation_and_translation(aa2matrix(axis, pi / 6),
[0, 0, 0])
if pga.is_valid_op(op):
symm_m.append(op)
#Any molecule with infinitesimal symmetry is linear;
#Thus, it possess mirror symmetry for any axis perpendicular
#To the rotational axis. pymatgen does not add this symmetry
#for all linear molecules - for example, hydrogen
if axis == [1, 0, 0]:
symm_m.append(SymmOp.from_xyz_string('x,-y,z'))
symm_m.append(SymmOp.from_xyz_string('x,y,-z'))
elif axis == [0, 1, 0]:
symm_m.append(SymmOp.from_xyz_string('-x,y,z'))
symm_m.append(SymmOp.from_xyz_string('x,y,-z'))
elif axis == [0, 0, 1]:
symm_m.append(SymmOp.from_xyz_string('-x,y,z'))
symm_m.append(SymmOp.from_xyz_string('x,-y,z'))
#Generate a full list of SymmOps for the molecule's pointgroup
symm_m = generate_full_symmops(symm_m, 1e-3)
break
#Reorient the SymmOps into mol's original frame
if not already_oriented:
new = []
for op in symm_m:
new.append(P.inverse * op * P)
return new
elif already_oriented:
return symm_m
#Handle nonlinear molecules
else:
pg = pga.get_pointgroup()
symm_m = []
for op in pg:
symm_m.append(op)
return symm_m
def orientation_in_wyckoff_position(
mol,
wyckoff_position,
randomize=True,
exact_orientation=False,
already_oriented=False,
allow_inversion=True,
rtol=1e-2,
):
"""
Tests if a molecule meets the symmetry requirements of a Wyckoff position,
and returns the valid orientations.
Args:
mol: a Molecule object. Orientation is arbitrary
wyckoff_position: a pyxtal.symmetry.Wyckoff_position object
randomize: whether or not to apply a random rotation consistent with
the symmetry requirements
exact_orientation: whether to only check compatibility for the provided
orientation of the molecule. Used within general case for checking.
If True, this function only returns True or False
already_oriented: whether or not to reorient the principle axes
when calling get_symmetry. Setting to True can remove redundancy,
but is not necessary
allow_inversion: whether or not to allow chiral molecules to be
inverted. Should only be True if the chemical and biological
properties of the mirror image are known to be suitable for the
desired application
Returns:
a list of operations.Orientation objects which can be applied to the
molecule while allowing it to satisfy the symmetry requirements of the
Wyckoff position. If no orientations are found, returns False.
"""
# For single atoms, there are no constraints
if len(mol) == 1:
return [Orientation([[1, 0, 0], [0, 1, 0], [0, 0, 1]], degrees=2)]
wyckoffs = wyckoff_position.ops
w_symm = wyckoff_position.symmetry_m
# Obtain the Wyckoff symmetry
symm_w = w_symm[0]
pga = PointGroupAnalyzer(mol)
# Check exact orientation
if exact_orientation is True:
mo = deepcopy(mol)
valid = True
for op in symm_w:
if not pga.is_valid_op(op):
valid = False
if valid is True:
return True
elif valid is False:
return False
# Obtain molecular symmetry, exact_orientation==False
symm_m = get_symmetry(mol, already_oriented=already_oriented)
# Store OperationAnalyzer objects for each molecular SymmOp
chiral = True
opa_m = []
for op_m in symm_m:
opa = OperationAnalyzer(op_m)
opa_m.append(opa)
if opa.type == "rotoinversion":
chiral = False
elif opa.type == "inversion":
chiral = False
# If molecule is chiral and allow_inversion is False,
# check if WP breaks symmetry
if chiral is True:
if allow_inversion is False:
for op in wyckoffs:
if np.linalg.det(op.rotation_matrix) < 0:
printx(
"Warning: cannot place chiral molecule in spagegroup",
priority=2,
)
return False
# Store OperationAnalyzer objects for each Wyckoff symmetry SymmOp
opa_w = []
for op_w in symm_w:
opa_w.append(OperationAnalyzer(op_w))
# Check for constraints from the Wyckoff symmetry...
# If we find ANY two constraints (SymmOps with unique axes), the molecule's
# point group MUST contain SymmOps which can be aligned to these particular
# constraints. However, there may be multiple compatible orientations of the
# molecule consistent with these constraints
constraint1 = None
constraint2 = None
for i, op_w in enumerate(symm_w):
if opa_w[i].axis is not None:
constraint1 = opa_w[i]
for j, op_w in enumerate(symm_w):
if opa_w[j].axis is not None:
dot = np.dot(opa_w[i].axis, opa_w[j].axis)
if (not np.isclose(dot, 1, rtol=rtol)) and (not np.isclose(
dot, -1, rtol=rtol)):
constraint2 = opa_w[j]
break
break
# Indirectly store the angle between the constraint axes
if constraint1 is not None and constraint2 is not None:
dot_w = np.dot(constraint1.axis, constraint2.axis)
# Generate 1st consistent molecular constraints
constraints_m = []
if constraint1 is not None:
for i, opa1 in enumerate(opa_m):
if opa1.is_conjugate(constraint1):
constraints_m.append([opa1, []])
# Generate 2nd constraint in opposite direction
extra = deepcopy(opa1)
extra.axis = [
opa1.axis[0] * -1, opa1.axis[1] * -1, opa1.axis[2] * -1
]
constraints_m.append([extra, []])
# Remove redundancy for the first constraints
list_i = list(range(len(constraints_m)))
list_j = list(range(len(constraints_m)))
copy = deepcopy(constraints_m)
for i, c1 in enumerate(copy):
if i in list_i:
for j, c2 in enumerate(copy):
if i > j and j in list_j and j in list_i:
# Check if axes are colinear
if np.isclose(np.dot(c1[0].axis, c2[0].axis), 1,
rtol=rtol):
list_i.remove(j)
list_j.remove(j)
# Check if axes are symmetrically equivalent
else:
cond1 = False
# cond2 = False
for opa in opa_m:
if opa.type == "rotation":
op = opa.op
if np.isclose(
np.dot(op.operate(c1[0].axis),
c2[0].axis),
1,
rtol=5 * rtol,
):
cond1 = True
break
if cond1 is True: # or cond2 is True:
list_i.remove(j)
list_j.remove(j)
c_m = deepcopy(constraints_m)
constraints_m = []
for i in list_i:
constraints_m.append(c_m[i])
# Generate 2nd consistent molecular constraints
valid = list(range(len(constraints_m)))
if constraint2 is not None:
for i, c in enumerate(constraints_m):
opa1 = c[0]
for j, opa2 in enumerate(opa_m):
if opa2.is_conjugate(constraint2):
dot_m = np.dot(opa1.axis, opa2.axis)
# Ensure that the angles are equal
if abs(dot_m - dot_w) < 0.02 or abs(dot_m + dot_w) < 0.02:
constraints_m[i][1].append(opa2)
# Generate 2nd constraint in opposite direction
extra = deepcopy(opa2)
extra.axis = [
opa2.axis[0] * -1,
opa2.axis[1] * -1,
opa2.axis[2] * -1,
]
constraints_m[i][1].append(extra)
# If no consistent constraints are found, remove first constraint
if constraints_m[i][1] == []:
valid.remove(i)
copy = deepcopy(constraints_m)
constraints_m = []
for i in valid:
constraints_m.append(copy[i])
# Generate orientations consistent with the possible constraints
orientations = []
# Loop over molecular constraint sets
for c1 in constraints_m:
v1 = c1[0].axis
v2 = constraint1.axis
T = rotate_vector(v1, v2)
# If there is only one constraint
if c1[1] == []:
o = Orientation(T, degrees=1, axis=constraint1.axis)
orientations.append(o)
else:
# Loop over second molecular constraints
for opa in c1[1]:
phi = angle(constraint1.axis, constraint2.axis)
phi2 = angle(constraint1.axis, np.dot(T, opa.axis))
if np.isclose(phi, phi2, rtol=rtol):
r = np.sin(phi)
c = np.linalg.norm(np.dot(T, opa.axis) - constraint2.axis)
theta = np.arccos(1 - (c**2) / (2 * (r**2)))
# R = aa2matrix(constraint1.axis, theta)
R = Rotation.from_rotvec(theta *
constraint1.axis).as_matrix()
T2 = np.dot(R, T)
a = angle(np.dot(T2, opa.axis), constraint2.axis)
if not np.isclose(a, 0, rtol=rtol):
T2 = np.dot(np.linalg.inv(R), T)
o = Orientation(T2, degrees=0)
orientations.append(o)
# Ensure the identity orientation is checked if no constraints are found
if constraints_m == []:
o = Orientation(np.identity(3), degrees=2)
orientations.append(o)
# Remove redundancy from orientations
list_i = list(range(len(orientations)))
list_j = list(range(len(orientations)))
for i, o1 in enumerate(orientations):
if i in list_i:
for j, o2 in enumerate(orientations):
if i > j and j in list_j and j in list_i:
# m1 = o1.get_matrix(angle=0)
# m2 = o2.get_matrix(angle=0)
m1 = o1.matrix
m2 = o2.matrix
new_op = SymmOp.from_rotation_and_translation(
np.dot(m2, np.linalg.inv(m1)), [0, 0, 0])
P = SymmOp.from_rotation_and_translation(
np.linalg.inv(m1), [0, 0, 0])
old_op = P * new_op * P.inverse
if pga.is_valid_op(old_op):
list_i.remove(j)
list_j.remove(j)
#copies = deepcopy(orientations)
orientations_new = []
for i in list_i:
orientations_new.append(orientations[i])
#Check each of the found orientations for consistency with the Wyckoff pos.
#If consistent, put into an array of valid orientations
allowed = []
for o in orientations_new:
if randomize is True:
op = o.get_op()
elif randomize is False:
op = o.get_op() #do not change
mo = deepcopy(mol)
mo.apply_operation(op)
if orientation_in_wyckoff_position(mo,
wyckoff_position,
exact_orientation=True,
randomize=False,
allow_inversion=allow_inversion):
allowed.append(o)
if allowed == []:
return False
else:
return allowed
def get_symmetry(mol, already_oriented=False):
"""
Return a molecule's point symmetry.
Note: for linear molecules, infinitessimal rotations are treated as 6-fold
rotations, which works for 3d and 2d point groups.
Args:
mol: a Molecule object
already_oriented: whether or not the principle axes of mol are already
reoriented. Can save time if True, but is not required.
Returns:
a list of SymmOp objects which leave the molecule unchanged when applied
"""
# For single atoms, we cannot represent the point group using a list of operations
if len(mol) == 1:
return []
pga = PointGroupAnalyzer(mol)
# Handle linear molecules
if "*" in pga.sch_symbol:
if not already_oriented:
# Reorient the molecule
oriented_mol, P = reoriented_molecule(mol)
pga = PointGroupAnalyzer(oriented_mol)
pg = pga.get_pointgroup()
symm_m = []
for op in pg:
symm_m.append(op)
# Add 12-fold and reflections in place of ininitesimal rotation
for axis in [[1, 0, 0], [0, 1, 0], [0, 0, 1]]:
# op = SymmOp.from_rotation_and_translation(aa2matrix(axis, np.pi/6), [0,0,0])
m1 = Rotation.from_rotvec(np.pi / 6 * axis).as_matrix()
op = SymmOp.from_rotation_and_translation(m1, [0, 0, 0])
if pga.is_valid_op(op):
symm_m.append(op)
# Any molecule with infinitesimal symmetry is linear;
# Thus, it possess mirror symmetry for any axis perpendicular
# To the rotational axis. pymatgen does not add this symmetry
# for all linear molecules - for example, hydrogen
if axis == [1, 0, 0]:
symm_m.append(SymmOp.from_xyz_string("x,-y,z"))
symm_m.append(SymmOp.from_xyz_string("x,y,-z"))
#r = SymmOp.from_xyz_string("-x,y,-z")
elif axis == [0, 1, 0]:
symm_m.append(SymmOp.from_xyz_string("-x,y,z"))
symm_m.append(SymmOp.from_xyz_string("x,y,-z"))
#r = SymmOp.from_xyz_string("-x,-y,z")
elif axis == [0, 0, 1]:
symm_m.append(SymmOp.from_xyz_string("-x,y,z"))
symm_m.append(SymmOp.from_xyz_string("x,-y,z"))
#r = SymmOp.from_xyz_string("x,-y,-z")
# Generate a full list of SymmOps for the molecule's pointgroup
symm_m = generate_full_symmops(symm_m, 1e-3)
break
# Reorient the SymmOps into mol's original frame
if not already_oriented:
new = []
for op in symm_m:
new.append(P.inverse * op * P)
return new
elif already_oriented:
return symm_m
# Handle nonlinear molecules
else:
pg = pga.get_pointgroup()
symm_m = []
for op in pg:
symm_m.append(op)
return symm_m
def orientation_in_wyckoff_position(mol,
sg,
index,
randomize=True,
exact_orientation=False,
already_oriented=False,
allow_inversion=False):
'''
Tests if a molecule meets the symmetry requirements of a Wyckoff position.
If it does, return the rotation matrix needed. Otherwise, returns False.
args:
mol: pymatgen.core.structure.Molecule object. Orientation is arbitrary
sg: the spacegroup to check
index: the index of the Wyckoff position within the sg to check
randomize: whether or not to apply a random rotation consistent with
the symmetry requirements.
exact_orientation: whether to only check compatibility for the provided
orientation of the molecule. Used within general case for checking.
If True, this function only returns True or False
already_oriented: whether or not to reorient the principle axes
when calling get_symmetry. Setting to True can remove redundancy,
but is not necessary.
'''
#Obtain the Wyckoff symmetry
symm_w = get_wyckoff_symmetry(sg, molecular=True)[index][0]
pga = PointGroupAnalyzer(mol)
#Check exact orientation
if exact_orientation is True:
mo = deepcopy(mol)
valid = True
for op in symm_w:
if not pga.is_valid_op(op):
valid = False
if valid is True:
return True
elif valid is False:
return False
#Obtain molecular symmetry, exact_orientation==False
symm_m = get_symmetry(mol, already_oriented=already_oriented)
#Store OperationAnalyzer objects for each molecular SymmOp
chiral = True
opa_m = []
for op_m in symm_m:
opa = OperationAnalyzer(op_m)
opa_m.append(opa)
if opa.type == "rotoinversion":
chiral = False
elif opa.type == "inversion":
chiral = False
#If molecule is chiral and allow_inversion is False,
#check if WP breaks symmetry
if chiral is True:
if allow_inversion is False:
gen_pos = get_wyckoffs(sg)[0]
for op in gen_pos:
if np.linalg.det(op.rotation_matrix) < 0:
print(
"Warning: cannot place chiral molecule in spagegroup #"
+ str(sg))
return False
#Store OperationAnalyzer objects for each Wyckoff symmetry SymmOp
opa_w = []
for op_w in symm_w:
opa_w.append(OperationAnalyzer(op_w))
#Check for constraints from the Wyckoff symmetry...
#If we find ANY two constraints (SymmOps with unique axes), the molecule's
#point group MUST contain SymmOps which can be aligned to these particular
#constraints. However, there may be multiple compatible orientations of the
#molecule consistent with these constraints
constraint1 = None
constraint2 = None
for i, op_w in enumerate(symm_w):
if opa_w[i].axis is not None:
constraint1 = opa_w[i]
for j, op_w in enumerate(symm_w):
if opa_w[j].axis is not None:
dot = np.dot(opa_w[i].axis, opa_w[j].axis)
if (not np.isclose(dot, 1, rtol=.01)) and (not np.isclose(
dot, -1, rtol=.01)):
constraint2 = opa_w[j]
break
break
#Indirectly store the angle between the constraint axes
if (constraint1 is not None and constraint2 is not None):
dot_w = np.dot(constraint1.axis, constraint2.axis)
#Generate 1st consistent molecular constraints
constraints_m = []
if constraint1 is not None:
for i, opa1 in enumerate(opa_m):
if opa1.is_conjugate(constraint1):
constraints_m.append([opa1, []])
#Generate 2nd constraint in opposite direction
extra = deepcopy(opa1)
extra.axis = [
opa1.axis[0] * -1, opa1.axis[1] * -1, opa1.axis[2] * -1
]
constraints_m.append([extra, []])
#Remove redundancy for the first constraints
list_i = list(range(len(constraints_m)))
list_j = list(range(len(constraints_m)))
copy = deepcopy(constraints_m)
for i, c1 in enumerate(copy):
if i in list_i:
for j, c2 in enumerate(copy):
if i > j and j in list_j and j in list_i:
#Check if axes are colinear
if np.isclose(np.dot(c1[0].axis, c2[0].axis), 1, rtol=.01):
list_i.remove(j)
list_j.remove(j)
else: # np.isclose(np.dot(c1[0].axis, c2[0].axis), -1, rtol=.01):
cond1 = False
cond2 = False
for opa in opa_m:
if opa.type == "rotation":
op = opa.op
if np.isclose(np.dot(op.operate(c1[0].axis),
c2[0].axis),
1,
rtol=.05):
cond1 = True
break
if cond1 is True: # or cond2 is True:
list_i.remove(j)
list_j.remove(j)
c_m = deepcopy(constraints_m)
constraints_m = []
for i in list_i:
constraints_m.append(c_m[i])
#Generate 2nd consistent molecular constraints
valid = range(len(constraints_m))
if constraint2 is not None:
for i, c in enumerate(constraints_m):
opa1 = c[0]
for j, opa2 in enumerate(opa_m):
if opa2.is_conjugate(constraint2):
dot_m = np.dot(opa1.axis, opa2.axis)
#Ensure that the angles are equal
if abs(dot_m - dot_w) < .02 or abs(dot_m + dot_w) < .02:
constraints_m[i][1].append(opa2)
#Generate 2nd constraint in opposite direction
extra = deepcopy(opa2)
extra.axis = [
opa2.axis[0] * -1, opa2.axis[1] * -1,
opa2.axis[2] * -1
]
constraints_m[i][1].append(extra)
#If no consistent constraints are found, remove first constraint
if constraints_m[i][1] == []:
valid.remove(i)
copy = deepcopy(constraints_m)
constraints_m = []
for i in valid:
constraints_m.append(copy[i])
#Generate orientations consistent with the possible constraints
orientations = []
#Loop over molecular constraint sets
for c1 in constraints_m:
v1 = c1[0].axis
v2 = constraint1.axis
T = rotate_vector(v1, v2)
#Loop over second molecular constraints
for opa in c1[1]:
phi = angle(constraint1.axis, constraint2.axis)
phi2 = angle(constraint1.axis, np.dot(T, opa.axis))
if isclose(phi, phi2, rtol=.01):
r = np.sin(phi)
c = np.linalg.norm(np.dot(T, opa.axis) - constraint2.axis)
theta = np.arccos(1 - (c**2) / (2 * (r**2)))
R = aa2matrix(constraint1.axis, theta)
T2 = np.dot(R, T)
a = angle(np.dot(T2, opa.axis), constraint2.axis)
if not np.isclose(a, 0, rtol=.01):
T2 = np.dot(np.linalg.inv(R), T)
a = angle(np.dot(T2, opa.axis), constraint2.axis)
if not np.isclose(a, 0, rtol=.01):
print("Error: Generated incorrect rotation: " + str(theta))
o = orientation(T2, degrees=0)
orientations.append(o)
#If there is only one constraint
if c1[1] == []:
o = orientation(T, degrees=1, axis=constraint1.axis)
orientations.append(o)
#Ensure the identity orientation is checked if no constraints are found
if constraints_m == []:
o = orientation(np.identity(3), degrees=2)
orientations.append(o)
#Remove redundancy from orientations
list_i = list(range(len(orientations)))
list_j = list(range(len(orientations)))
for i, o1 in enumerate(orientations):
if i in list_i:
for j, o2 in enumerate(orientations):
if i > j and j in list_j and j in list_i:
m1 = o1.get_matrix(angle=0)
m2 = o2.get_matrix(angle=0)
new_op = SymmOp.from_rotation_and_translation(
np.dot(m2, np.linalg.inv(m1)), [0, 0, 0])
P = SymmOp.from_rotation_and_translation(
np.linalg.inv(m1), [0, 0, 0])
old_op = P * new_op * P.inverse
if pga.is_valid_op(old_op):
list_i.remove(j)
list_j.remove(j)
copy = deepcopy(orientations)
orientations = []
for i in list_i:
orientations.append(copy[i])
#Check each of the found orientations for consistency with the Wyckoff pos.
#If consistent, put into an array of valid orientations
allowed = []
for o in orientations:
if randomize is True:
op = o.get_op()
elif randomize is False:
op = o.get_op(angle=0)
mo = deepcopy(mol)
mo.apply_operation(op)
if orientation_in_wyckoff_position(
mo,
sg,
index,
exact_orientation=True,
already_oriented=already_oriented) is True:
allowed.append(o)
#Return the array of allowed orientations. If there are none, return False
if allowed == []:
return False
else:
return allowed
def orientation_in_wyckoff_position(mol,
sg,
index,
randomize=True,
exact_orientation=False,
already_oriented=False):
'''
Tests if a molecule meets the symmetry requirements of a Wyckoff position.
If it does, return the rotation matrix needed. Otherwise, returns False.
args:
mol: pymatgen.core.structure.Molecule object. Orientation is arbitrary
sg: the spacegroup to check
index: the index of the Wyckoff position within the sg to check
randomize: whether or not to apply a random rotation consistent with
the symmetry requirements.
exact_orientation: whether to only check compatibility for the provided
orientation of the molecule. Used within general case for checking.
If True, this function only returns True or False
'''
#Obtain the Wyckoff symmetry
symm_w_unedited = get_wyckoff_symmetry(sg)[index][0]
found_params = []
symm_w_partial = []
symm_w = []
orthogonal = True
#Check if operations are orthogonal; 3-fold and 6-fold operations are not
for op in symm_w_unedited:
m1 = np.dot(op.rotation_matrix, np.transpose(op.rotation_matrix))
m2 = np.dot(np.transpose(op.rotation_matrix), op.rotation_matrix)
if (not allclose(m1, np.identity(3))) or (not allclose(
m2, np.identity(3))):
rotation_order = 0
d = np.linalg.det(op.rotation_matrix)
if isclose(d, 1):
op_type = "rotation"
elif isclose(d, -1):
op_type = "improper rotation"
if op_type == "rotation":
newop = deepcopy(op)
for n in range(1, 7):
newop = (newop * op)
if allclose(newop.rotation_matrix,
np.identity(3),
rtol=1e-2):
rotation_order = n + 1
break
elif op_type == "improper rotation":
#We only want the order of the rotational part of op,
#So we multiply op by -1 for rotoinversions
op_1 = SymmOp.from_rotation_and_translation(
op.rotation_matrix * -1, [0, 0, 0])
new_op = deepcopy(op_1)
for n in range(1, 7):
newop = (newop * op_1)
if allclose(newop.rotation_matrix, np.identity(3)):
rotation_order = n + 1
break
if rotation_order == 0:
print("Error: could not convert to orthogonal operation:")
print(op)
symm_w_partial.append(op)
else:
params = [rotation_order, op_type]
if params not in found_params:
found_params.append(params)
else:
symm_w_partial.append(op)
#Add 3-fold and 6-fold symmetry back in using absolute coordinates
for params in found_params:
order = params[0]
op_type = params[1]
if op_type == "rotation" and (order == 3 or order == 6):
m = aa2matrix([0, 0, 1], (2 * pi) / order)
elif op_type == "improper rotation" and (order == 3 or order == 6):
m = aa2matrix([0, 0, 1], 2 * pi / order)
m[2] *= -1
symm_w_partial.append(
SymmOp.from_rotation_and_translation(m, [0, 0, 0]))
symm_w = generate_full_symmops(symm_w_partial, 1e-3)
#Check exact orientation
if exact_orientation is True:
mo = deepcopy(mol)
pga = PointGroupAnalyzer(mo)
valid = True
for op in symm_w:
op_w = SymmOp.from_rotation_and_translation(
op.rotation_matrix, [0, 0, 0])
if not pga.is_valid_op(op_w):
valid = False
if valid is True:
return True
elif valid is False:
return False
#Obtain molecular symmetry, exact_orientation==False
symm_m = get_symmetry(mol, already_oriented=already_oriented)
#Store OperationAnalyzer objects for each SymmOp
opa_w = []
for op_w in symm_w:
opa_w.append(OperationAnalyzer(op_w))
opa_m = []
for op_m in symm_m:
opa_m.append(OperationAnalyzer(op_m))
#Check for constraints from the Wyckoff symmetry...
#If we find ANY two constraints (SymmOps with unique axes), the molecule's
#point group MUST contain SymmOps which can be aligned to these particular
#constraints. However, there may be multiple compatible orientations of the
#molecule consistent with these constraints
constraint1 = None
constraint2 = None
for i, op_w in enumerate(symm_w):
if opa_w[i].axis is not None:
constraint1 = opa_w[i]
for j, op_w in enumerate(symm_w):
if opa_w[j].axis is not None:
dot = np.dot(opa_w[i].axis, opa_w[j].axis)
if (not isclose(dot, 1)) and (not isclose(dot, -1)):
constraint2 = opa_w[j]
break
break
#Indirectly store the angle between the constraint axes
if (constraint1 is not None and constraint2 is not None):
dot_w = np.dot(constraint1.axis, constraint2.axis)
#Store corresponding symmetry elements of the molecule
constraints_m = []
if constraint1 is not None:
for i, op_m in enumerate(symm_m):
if opa_m[i].is_conjugate(constraint1):
constraints_m.append([opa_m[i], []])
if constraint2 is not None:
for j, op_m2 in enumerate(symm_m):
if opa_m[j].is_conjugate(constraint2):
dot_m = np.dot(opa_m[i].axis, opa_m[j].axis)
#Ensure that the angles are equal
if isclose(dot_m, dot_w):
constraints_m[-1][1].append(opa_m[j])
#Eliminate redundancy for 1st constraint
list_i = list(range(len(constraints_m)))
list_j = list(range(len(constraints_m)))
for i, c1 in enumerate(constraints_m):
if i in list_i:
for j, c2 in enumerate(constraints_m):
if i > j and j in list_j and j in list_i:
#check if c1 and c2 are symmetrically equivalent
#calculate moments of inertia about both axes
m1_a = get_moment_of_inertia(mol, c1[0].axis)
m2_a = get_moment_of_inertia(mol, c2[0].axis)
m1_b = get_moment_of_inertia(mol, c1[0].axis, scale=2.0)
m2_b = get_moment_of_inertia(mol, c2[0].axis, scale=2.0)
if isclose(m1_a, m2_a, rtol=1e-2) and isclose(
m1_b, m2_b, rtol=1e-2):
list_i.remove(j)
list_j.remove(j)
c_m = deepcopy(constraints_m)
constraints_m = []
for i in list_i:
constraints_m.append(c_m[i])
#Eliminate redundancy for second constraint
for k, c in enumerate(constraints_m):
if c[1] != []:
list_i = list(range(len(c[1])))
list_j = list(range(len(c[1])))
for i, c1 in enumerate(c[1]):
if i in list_i:
for j, c2 in enumerate(c[1]):
if j > i and j in list_j and j in list_i:
#check if c1 and c2 are symmetrically equivalent
#calculate moments of inertia about both axes
m1_a = get_moment_of_inertia(mol, c1.axis)
m2_a = get_moment_of_inertia(mol, c2.axis)
m1_b = get_moment_of_inertia(mol,
c1.axis,
scale=2.0)
m2_b = get_moment_of_inertia(mol,
c2.axis,
scale=2.0)
if isclose(m1_a, m2_a, rtol=1e-2) and isclose(
m1_b, m2_b, rtol=1e-2):
list_i.remove(j)
list_j.remove(j)
c_m = deepcopy(c[1])
constraints_m[k][1] = []
for i in list_i:
constraints_m[k][1].append(c_m[i])
#Generate orientations consistent with the possible constraints
orientations = []
#Loop over molecular constraint sets
for c1 in constraints_m:
v1 = c1[0].axis
v2 = constraint1.axis
T = rotate_vector(v1, v2)
#Loop over second molecular constraints
for opa in c1[1]:
v1 = np.dot(T, opa.axis)
v2 = constraint2.axis
R = rotate_vector(v1, v2)
T2 = np.dot(T, R)
orientations.append(T2)
if c1[1] == []:
if randomize is True:
angle = rand() * 2 * pi
R = aa2matrix(v1, angle)
T2 = np.dot(T, R)
orientations.append(T2)
else:
orientations.append(T)
#Ensure the identity orientation is checked if no constraints are found
if constraints_m == []:
if randomize is True:
R = aa2matrix(1, 1, random=True)
orientations.append(R)
else:
orientations.append(np.identity(3))
#Check each of the found orientations for consistency with the Wyckoff pos.
#If consistent, put into an array of valid orientations
allowed = []
for o in orientations:
o = SymmOp.from_rotation_and_translation(o, [0, 0, 0])
mo = deepcopy(mol)
mo.apply_operation(o)
if orientation_in_wyckoff_position(
mo,
sg,
index,
exact_orientation=True,
already_oriented=already_oriented) is True:
allowed.append(o)
#Return the array of allowed orientations. If there are none, return False
if allowed == []:
return False
else:
return allowed
