Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
check()
print(" class OperationAnalyzer")
try:
from pyxtal.operations import OperationAnalyzer
except Exception as e:
fail(e)
if passed():
try:
for i in range(10):
m = aa2matrix(1, 1, random=True)
t = random_vector()
op1 = SymmOp.from_rotation_and_translation(m, t)
OperationAnalyzer(op1)
except Exception as e:
fail(e)
check()
print(" class Orientation")
try:
from pyxtal.operations import Orientation
except Exception as e:
fail(e)
if passed():
try:
for i in range(10):
v1 = random_vector()
c1 = random_vector()
highest = get_highest_symbol(new_symbols)
symbol += highest
new_symbols.remove(highest)
if symbol == "":
printx("Error: could not combine site symmetry axes.", priority=1)
return
else:
return symbol
# Generate needed ops
if complete is False:
ops = generate_full_symmops(ops, 1e-3)
# Get OperationAnalyzer object for all ops
opas = []
for op in ops:
opas.append(OperationAnalyzer(op))
# Store the symmetry of each axis
params = [[], [], [], [], [], [], [], [], [], [], [], [], []]
has_inversion = False
# Store possible symmetry axes for crystallographic point groups
axes = [
[1, 0, 0],
[0, 1, 0],
[0, 0, 1],
[1, 1, 0],
[0, 1, 1],
[1, 0, 1],
[1, -1, 0],
[0, 1, -1],
[1, 0, -1],
[1, 1, 1],
[-1, 1, 1],
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
rotvec = Rotation.from_matrix(-1 * self.m).as_rotvec()
if np.sum(rotvec.dot(rotvec)) < 1e-6:
self.axis = None
self.angle = 0
else:
self.angle = np.linalg.norm(rotvec)
self.axis = rotvec / self.angle
if np.isclose(self.angle, 0):
self.type = "inversion"
self.order = int(2)
self.rotation_order = int(1)
else:
self.axis *= -1
self.type = "rotoinversion"
self.order = OperationAnalyzer.get_order(
self.angle, rotoinversion=True
)
self.rotation_order = OperationAnalyzer.get_order(
self.angle, rotoinversion=False
)
elif np.linalg.det(self.m) == 0:
self.type = "degenerate"
self.axis, self.angle = None, None
opa1 = OperationAnalyzer(op1)
return opa1.is_conjugate(op2)
# Test Functionality
if __name__ == "__main__":
# ----------------------------------------------------
op = SymmOp.from_rotation_and_translation(
Rotation.from_rotvec(np.pi / 6 * np.array([1, 0, 0])).as_matrix(), [0, 0, 0]
)
ops = [op]
from pymatgen.symmetry.analyzer import generate_full_symmops
symm_m = generate_full_symmops(ops, 1e-3)
for op in symm_m:
opa = OperationAnalyzer(op)
print(opa.order)
self.angle = 0
else:
self.angle = np.linalg.norm(rotvec)
self.axis = rotvec / self.angle
if np.isclose(self.angle, 0):
self.type = "inversion"
self.order = int(2)
self.rotation_order = int(1)
else:
self.axis *= -1
self.type = "rotoinversion"
self.order = OperationAnalyzer.get_order(
self.angle, rotoinversion=True
)
self.rotation_order = OperationAnalyzer.get_order(
self.angle, rotoinversion=False
)
elif np.linalg.det(self.m) == 0:
self.type = "degenerate"
self.axis, self.angle = None, None
def are_conjugate(op1, op2):
"""
Returns whether or not two operations are conjugate (the same
operation in a different reference frame). Rotations with the same order
will not always return True. For example, a 5/12 and 1/12 rotation will
not be considered conjugate.
Args:
op1: a SymmOp or OperationAnalyzer object
op2: a SymmOp or OperationAnalyzer object to compare with op1
Returns:
True if op2 is conjugate to op1, and False otherwise
"""
if type(op1) != OperationAnalyzer:
opa1 = OperationAnalyzer(op1)
return opa1.is_conjugate(op2)