def calculate_schmidttransformation(self):
a1 = canonical_e0
b1 = canonical_e1
c1 = canonical_e2
a2 = a1
a3 = a2 * (1 / self.length(a2))
b2 = b1 - a3 * self.dot(a3, b1)
b3 = b2 * (1 / self.length(b2))
c2 = c1 - a3 * self.dot(a3, c1) - b3 * self.dot(b3, c1)
c3 = c2 * (1 / self.length(c2))
M = nb.Matrix([[a3.x(), b3.x(), c3.x()], [a3.y(),
b3.y(),
c3.y()],
[a3.z(), b3.z(), c3.z()]]).inv()
transformation = Transformation(
nb.Matrix([[
M.liste[0].liste[0], M.liste[0].liste[1], M.liste[0].liste[2],
0
],
[
M.liste[1].liste[0], M.liste[1].liste[1],
M.liste[1].liste[2], 0
],
[
M.liste[2].liste[0], M.liste[2].liste[1],
M.liste[2].liste[2], 0
], [0, 0, 0, 1]]))
return transformation
def test_Transgen():
tg = geo.Transgen(geo.Dif(nb.Matrix([[1], [0], [0], [0]])),
geo.Dif(nb.Matrix([[0], [0], [2], [0]])),
geo.Dif(nb.Matrix([[0], [3], [0], [0]])))
assert tg.__str__() == "Transgen / 1 \ / 0 \ / 0 \ \n"\
" | 0 | | 0 | | 3 |\n"\
" \ 0 / \ 2 / \ 0 / "
def test_Pos():
x = geo.Pos(nb.Matrix([[1], [2], [3], [1]]))
assert x.__str__() == "Pos / 1 \ \n | 2 |\n \ 3 / "
assert x.x() == 1
assert x.y() == 2
assert x.z() == 3
x = geo.origin
assert x == geo.Pos(nb.Matrix([[0], [0], [0], [1]]))
def test_Dif():
x = geo.Dif(nb.Matrix([[1], [2], [3], [0]]))
assert x.__str__() == "Dif / 1 \ \n | 2 |\n \ 3 / "
assert x.x() == 1
assert x.y() == 2
assert x.z() == 3
assert x.to_Symmetry() == geo.Symmetry(
nb.Matrix([[1, 0, 0, 1], [0, 1, 0, 2], [0, 0, 1, 3], [0, 0, 0, 1]]))
def test_Rec():
q = geo.Rec(nb.Matrix([[1, 2, 3, 0]]))
assert q.__str__() == "Rec < 1 2 3 > "
assert q.h() == 1
assert q.k() == 2
assert q.l() == 3
x = geo.Rec(nb.Matrix([[0, 0, 1.00000000, 0]]))
y = geo.Rec(nb.Matrix([[0, 0, 0.99999999, 0]]))
assert hash(x) == hash(y)
def test_Spacegroup():
transgen = geo.canonical
c1 = geo.Coset(geo.Symmetry(nb.Matrix.onematrix(4)), transgen)
c2 = geo.Coset(
geo.Symmetry(
nb.Matrix([[-1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0],
[0, 0, 0, 1]])), transgen)
sg = geo.Spacegroup(transgen, [c1, c2])
assert sg.__str__() == \
"Spacegroup \n"\
"---------- \n"\
" canonical \n"\
" x,y,z\n"\
" -x,-y,-z"
transgen = geo.Transgen(geo.Dif(nb.Matrix([[1], [0], [0], [0]])),
geo.Dif(nb.Matrix([[0], [1], [0], [0]])),
geo.Dif(nb.Matrix([[0], [0], [2], [0]])))
c1 = geo.Coset(geo.Symmetry(nb.Matrix.onematrix(4)), transgen)
c2 = geo.Coset(
geo.Symmetry(
nb.Matrix([[-1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0],
[0, 0, 0, 1]])), transgen)
sg = geo.Spacegroup(transgen, [c1, c2])
assert sg.__str__() == \
" Spacegroup \n"\
" ---------- \n"\
"Transgen / 1 \ / 0 \ / 0 \ \n"\
" | 0 | | 1 | | 0 | \n"\
" \ 0 / \ 0 / \ 2 / \n"\
" x,y,z\n"\
" -x,-y,-z"
sg = geo.Spacegroup(geo.canonical, [
geo.Coset(geo.Symmetry(nb.Matrix.onematrix(4)), geo.canonical),
geo.Coset(
geo.Symmetry(
nb.Matrix([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 1, 0],
[0, 0, 0, 1]])), geo.canonical)
])
transformation = geo.Transformation(
nb.Matrix([[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]))
sg1 = transformation**sg
sg2 = geo.Spacegroup(transformation**geo.canonical, [
geo.Coset(geo.Symmetry(nb.Matrix.onematrix(4)), geo.canonical),
geo.Coset(
geo.Symmetry(
nb.Matrix([[-1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0],
[0, 0, 0, 1]])), geo.canonical)
])
assert sg.is_really_a_spacegroup() == True
sg_error = geo.Spacegroup(geo.canonical, [
geo.Coset(geo.Symmetry(nb.Matrix.onematrix(4)), geo.canonical),
geo.Coset(
geo.Symmetry(
nb.Matrix([[1, 0, 0, fr.Fraction(1, 4)], [0, 1, 0, 0],
[0, 0, 1, 0], [0, 0, 0, 1]])), geo.canonical)
])
assert sg_error.is_really_a_spacegroup() == False
def test_Operator():
id = geo.Operator(
nb.Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]))
g = geo.Operator(
nb.Matrix([[-1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]))
g1 = geo.Operator(
nb.Matrix([[-1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]))
assert g.__str__() == "Operator / -1 0 0 0 \ \n"\
" | 0 -1 0 0 |\n"\
" | 0 0 1 0 |\n"\
" \ 0 0 0 1 / "
assert g == g1
def __mul__(self, right):
if isinstance(right, nb.Mixed):
return Dif(
nb.Matrix([[right * self.x()], [right * self.y()],
[right * self.z()], [0]]))
else:
return NotImplemented
def test_Symmetry():
g = geo.Symmetry(
nb.Matrix([[1, 0, 2, -1], [0, -2, 0, 0], [0, 0, 1,
fr.Fraction(1, 3)],
[0, 0, 0, 1]]))
assert g.__str__() == "x+2z-1,-2y,z+1/3"
assert isinstance(g.inv(), geo.Symmetry)
assert g * g.inv() == geo.Symmetry(nb.Matrix.onematrix(4))
def sort(self):
# This is the sorting of algorithm A of:
# H. D. Flack
# "The Derivation of Twin Laws for
# (Pseudo-)Merohedry by Coset
# Decomposition"
# Acta Cryst. (1987) A43, 564-568
#
identity = []
twofold_rotations = []
non_twofold_rotations = []
inversion = []
mirror_reflections = []
non_twofold_second_kind = []
id = Symmetry(
nb.Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0,
1]]))
I = Symmetry(
nb.Matrix([[-1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0],
[0, 0, 0, 1]]))
for symmetry in self.liste:
if symmetry == id:
identity.append(symmetry)
elif symmetry.value.det() == 1:
if symmetry * symmetry == id:
twofold_rotations.append(symmetry)
else:
non_twofold_rotations.append(symmetry)
else:
if symmetry == I:
inversion.append(symmetry)
elif symmetry * symmetry == id:
mirror_reflections.append(symmetry)
else:
non_twofold_second_kind.append(symmetry)
return Pointgroup(identity + twofold_rotations +
non_twofold_rotations + inversion +
mirror_reflections + non_twofold_second_kind)
def test_Symmetry():
g = geo.Symmetry(nb.Matrix([[1, 0, 2, -1],
[0, -2, 0, 0],
[0, 0, 1, fr.Fraction(1, 3)],
[0, 0, 0, 1]]))
assert g.__str__() == "x+2z-1,-2y,z+1/3"
assert isinstance(g.inv(), geo.Symmetry)
assert g * g.inv() == geo.Symmetry(nb.Matrix.onematrix(4))
g = geo.Symmetry(nb.Matrix([[0,-1, 0, 0],
[1, -1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]]))
print(g)
assert g.__str__() == "-y,x-y,z"
x = uc.ufloat(0.4, 0.1)
p = geo.Pos(nb.Matrix([[x], [x], [0], [1]]))
print(p)
print((g*g*g)**p)
assert (g*g*g)**p == p
def centre_of_gravity(liste):
# Calculates the centre of gravity of a list of positions
# of type geo.Pos.
assert isinstance(liste, list), \
"Argument of geo.centre_of_gravity(...) must be of type list."
for item in liste:
assert isinstance(item, Pos), \
"Argument of geo.centre_of_gravity(...) must be a list " \
"of objects of type geo.Pos."
summe = Dif(nb.Matrix([[0], [0], [0], [0]]))
for item in liste:
summe += item - origin
return origin + Dif((summe.value * (1 / nb.Mixed(len(liste)))))
def __str__(self):
result = 'Transformation '
m = self.value.inv()
Ox = m.liste[0].liste[3]
Oy = m.liste[1].liste[3]
Oz = m.liste[2].liste[3]
matrix = nb.Matrix([[1, 0, 0, Ox], [0, 1, 0, Oy], [0, 0, 1, Oz],
[0, 0, 0, 1]])
result = "Transformation O -> (%s, %s, %s)\n" \
" then\n" % \
(Ox.__str__(), Oy.__str__(), Oz.__str__())
matrix = nb.Matrix([
nb.Row([
m.liste[0].liste[0], m.liste[1].liste[0], m.liste[2].liste[0],
0
]),
nb.Row([
m.liste[0].liste[1], m.liste[1].liste[1], m.liste[2].liste[1],
0
]),
nb.Row([
m.liste[0].liste[2], m.liste[1].liste[2], m.liste[2].liste[2],
0
]),
nb.Row([
m.liste[3].liste[0], m.liste[3].liste[1], m.liste[3].liste[2],
1
])
])
terms = []
for i in range(3):
print(matrix.liste[i].liste[0], matrix.liste[i].liste[1],
matrix.liste[i].liste[2], matrix.liste[i].liste[3])
terms.append(
linearterm2str(matrix.liste[i].liste, ["a", "b", "c", '']))
return result + " a' = " + terms[0] + "\n" \
+ " b' = " + terms[1] + "\n" \
+ " c' = " + terms[2]
def symmetryfromstr(string):
words = string.split(',')
assert len(words) == 3, \
"The following string looks like a Symmetry, but it has not "\
"three comma-separated terms: %s" % (string)
liste = []
for word in words:
row = nb.Row(str2linearterm(word, ['x', 'y', 'z']))
liste.append(row)
liste.append(
nb.Row([fromstr("0"),
fromstr("0"),
fromstr("0"),
fromstr("1")]))
return geo.Symmetry(nb.Matrix(liste))
def test_eq():
r1 = geo.Pos(nb.Matrix([[1], [2], [3], [1]]))
r2 = geo.Pos(nb.Matrix([[1], [2], [3], [1]]))
r3 = geo.Pos(nb.Matrix([[1], [2], [4], [1]]))
d1 = geo.Dif(nb.Matrix([[4], [5], [6], [0]]))
d2 = geo.Dif(nb.Matrix([[4], [5], [6], [0]]))
d3 = geo.Dif(nb.Matrix([[3], [5], [6], [0]]))
q1 = geo.Rec(nb.Matrix([[1, 2, 3, 0]]))
q2 = geo.Rec(nb.Matrix([[1, 2, 3, 0]]))
q3 = geo.Rec(nb.Matrix([[2, 3, 4, 0]]))
assert not (r1 == d1)
assert (r1 == r1)
assert (r1 == r2)
assert not (r1 == r3)
assert (d1 == d1)
assert (d1 == d2)
assert not (d1 == d3)
assert not (r1 == q1)
assert not (d1 == q1)
assert (q1 == q1)
assert (q1 == q2)
assert not (q1 == q3)
def to_Metric(self):
a = self.a
b = self.b
c = self.c
alpha = self.alpha
beta = self.beta
gamma = self.gamma
aa = a * a
bb = b * b
cc = c * c
ab = a * b * nb.cos(nb.deg2rad(gamma))
ac = a * c * nb.cos(nb.deg2rad(beta))
bc = b * c * nb.cos(nb.deg2rad(alpha))
return Metric(
nb.Matrix([
nb.Row([aa, ab, ac, 0]),
nb.Row([ab, bb, bc, 0]),
nb.Row([ac, bc, cc, 0]),
nb.Row([0, 0, 0, 1])
]))
def matrixfromstr(string):
string = string.replace('|', '\\')
string = re.sub('\/ | \/|[<>]', ' ', string)
# string = string.replace('/ ', ' ')
# string = string.replace('<', ' ')
# string = string.replace('>', ' ')
# string = string.replace(' /', ' ')
string = string.replace('\n', '\\')
# string = re.sub('\\\\ +\\\\', '\\', string)
for i in range(4):
string = string.replace('\\ \\', '\\')
string = string.replace('\\ \\', '\\')
string = string.replace('\\ \\', '\\')
rowwords = string.split('\\')
rowliste = []
for rowword in rowwords:
words = rowword.split()
liste = []
for word in words:
liste.append(mixedfromstr(word))
rowliste.append(nb.Row(liste))
return nb.Matrix(rowliste)
def __init__(self, b1, b2, b3):
assert isinstance(b1, Dif) \
and isinstance(b2, Dif) \
and isinstance(b3, Dif), \
"Arguments must be of type Dif."
self.liste = [b1, b2, b3]
m00 = b1.value.liste[0].liste[0]
m01 = b2.value.liste[0].liste[0]
m02 = b3.value.liste[0].liste[0]
m10 = b1.value.liste[1].liste[0]
m11 = b2.value.liste[1].liste[0]
m12 = b3.value.liste[1].liste[0]
m20 = b1.value.liste[2].liste[0]
m21 = b2.value.liste[2].liste[0]
m22 = b3.value.liste[2].liste[0]
self.transformation = Transformation(
nb.Matrix([
nb.Row([m00, m01, m02, 0]),
nb.Row([m10, m11, m12, 0]),
nb.Row([m20, m21, m22, 0]),
nb.Row([0, 0, 0, 1])
]))
self.transformationinv = self.transformation.inv()
def test_Metric():
M = nb.Matrix([[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])
metric = geo.Metric(M)
t = metric.schmidttransformation
assert t ** geo.canonical_e0 == geo.Dif(nb.Matrix([[1], [0], [0], [0]]))
assert t ** geo.canonical_e1 == geo.Dif(nb.Matrix([[0], [1], [0], [0]]))
assert t ** geo.canonical_e2 == geo.Dif(nb.Matrix([[0], [0], [1], [0]]))
metric = geo.Cellparameters(1, 1, 1, 90, 90, 45).to_Metric()
t = metric.schmidttransformation
assert t ** geo.canonical_e0 == geo.Dif(nb.Matrix([[1], [0], [0], [0]]))
e1 = t ** geo.canonical_e1
assert abs(e1.x() - 0.70710678).value < 0.000001
assert abs(e1.y() - 0.70710678).value < 0.000001
assert abs(e1.z() - 0).value < 0.000001
e2 = t ** geo.canonical_e2
assert abs(e2.x() - 0).value < 0.000001
assert abs(e2.y() - 0).value < 0.000001
assert abs(e2.z() - 1).value < 0.000001
t = metric.schmidttransformation.inv()
M = nb.Matrix([[9, 0, 0, 0],
[0, 4, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])
metric = geo.Metric(M)
assert metric.__str__() == "Metric / 9 0 0 0 \ \n" \
" | 0 4 0 0 |\n" \
" | 0 0 1 0 |\n" \
" \ 0 0 0 1 / "
o = geo.Pos(nb.Matrix([[0], [0], [0], [1]]))
p1 = geo.Pos(nb.Matrix([[1], [0], [0], [1]]))
p2 = geo.Pos(nb.Matrix([[0], [1], [0], [1]]))
q1 = geo.Rec(nb.Matrix([[1, 0, 0, 0]]))
q2 = geo.Rec(nb.Matrix([[0, 1, 0, 0]]))
q3 = geo.Rec(nb.Matrix([[1, 1, 0, 0]]))
assert metric.dot(p1 - o, p1 - o).__str__() == "9"
assert metric.dot(p1 - o, p2 - o).__str__() == "0"
assert metric.dot(q1, q1).__str__() == "1/9"
assert metric.dot(q2, q2).__str__() == "1/4"
assert metric.dot(q3, q3).__str__() == "13/36"
assert metric.length(p1 - o) == 3
assert np.abs(float(metric.angle(p1 - o, p2 - o)) - 1.5707963) < 0.0001
assert metric.dangle(p1 - o, p2 - o) == 90
assert metric.length(q1).__str__() == "1/3"
assert np.abs(float(metric.angle(q1, q2)) - 1.5707963) < 0.0001
assert metric.dangle(q1, q2) == 90
assert metric.angle(p1 - o, p1 - o).__str__() == "0.0"
assert metric.dangle(p1 - o, p1 - o).__str__() == "0"
assert metric.angle(q1, q1).__str__() == "0.0"
assert metric.dangle(q1, q1).__str__() == "0"
metric = geo.Cellparameters(4.15, 4.15, 28.64, 90, 90, 120).to_Metric()
M = nb.Matrix([[9, 0, 0, 0],
[0, 4, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])
metric = geo.Metric(M)
cell = metric.to_Cellparameters()
assert cell.__str__() == \
geo.Cellparameters(3, 2, 1, 90, 90, 90).__str__()
t = geo.Transformation(nb.Matrix([[0, 1, 0, 0],
[1, 0, 0, 0],
[0, 0, 1, 0.5],
[0, 0, 0, 1]]))
assert t ** metric == geo.Metric(nb.Matrix([[4, 0, 0, 0],
[0, 9, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]]))
metric = geo.Cellparameters(fs("8.534(5)"), fs("8.556(5)"), fs("7.015(5)"),
fs("101.53(8)"), fs("114.97(8)"),
fs("103.38(8)")).to_Metric()
assert np.abs(metric.cellvolume().value.n - 425.24239) < 0.0001
metric = geo.Cellparameters(fs("1.0(1)"), 1, 1, 90, 90, 90).to_Metric()
print(metric.cellvolume())
assert np.abs(metric.cellvolume().value.n - 1) < 0.00000001
assert np.abs(metric.cellvolume().value.s - 0.1) < 0.00000001
a = fs("1.0(1)")
metric = geo.Cellparameters(a, a, a, 90, 90, 90).to_Metric()
m00 = metric.value.liste[0].liste[0]
m11 = metric.value.liste[1].liste[1]
assert (m00 - m11).value.n == 0.0
assert (m00 - m11).value.s == 0.0
def test_Skalarprodukt():
d1 = geo.Dif(nb.Matrix([[1], [2], [3], [0]]))
q1 = geo.Rec(nb.Matrix([[4, 5, 6, 0]]))
assert q1 * d1 == 32
def test_centre_of_gravity():
p1 = geo.Pos(nb.Matrix([[1], [0], [0], [1]]))
p2 = geo.Pos(nb.Matrix([[3], [0], [0], [1]]))
assert geo.centre_of_gravity([p1, p2]) == geo.Pos(nb.Matrix([[2], [0], [0], [1]]))
def test_add_and_sub():
x1 = geo.Pos(nb.Matrix([[1], [2], [3], [1]]))
x2 = geo.Pos(nb.Matrix([[2], [3], [4], [1]]))
d1 = geo.Dif(nb.Matrix([[4], [5], [6], [0]]))
d2 = geo.Dif(nb.Matrix([[5], [5], [5], [0]]))
assert (x1 + d1) == geo.Pos(nb.Matrix([[5], [7], [9], [1]]))
assert (d1 + d2) == geo.Dif(nb.Matrix([[9], [10], [11], [0]]))
assert (d1 - d2) == geo.Dif(nb.Matrix([[-1], [0], [1], [0]]))
assert (x1 - d1) == geo.Pos(nb.Matrix([[-3], [-3], [-3], [1]]))
assert (x1 - x2) == geo.Dif(nb.Matrix([[-1], [-1], [-1], [0]]))
q1 = geo.Rec(nb.Matrix([[1, 2, 3, 0]]))
q2 = geo.Rec(nb.Matrix([[4, 5, 6, 0]]))
assert (q1 + q2) == geo.Rec(nb.Matrix([[5, 7, 9, 0]]))
assert (q1 - q2) == geo.Rec(nb.Matrix([[-3, -3, -3, 0]]))
assert -d1 == geo.Dif(nb.Matrix([[-4], [-5], [-6], [0]]))
assert -q1 == geo.Rec(nb.Matrix([[-1, -2, -3, 0]]))
def test_operations():
# Here I want to test all operations between equal and different types.
# It shall be as follows:
#
# * | Symmetry Transformation Transgen Coset Pos Dif Metric Spacegroup
# ----------------------------------------------------------------------------------------------
# Symmetry | Symmetry - - - - - - -
# Transformation | - Transformation - - - - - -
# Transgen | - - - - - - - -
# Coset | - - - Coset - - - -
# Pos | - - - - - - - -
# Dif | - - - - - - - -
# Metric | - - - - - - - -
# Spacegroup | - - - - - - - -
#
#
# ** | Symmetry Transformation Transgen Coset Pos Dif Metric Spacegroup
# -----------------------------------------------------------------------------------------------
# Symmetry | - - - - Pos Dif - -
# Transformation | Symmetry - Transgen Coset Pos Dif Metric Spacegroup
# Transgen | - - - - - - - -
# Coset | - - - - Pos Dif - -
# Pos | - - - - - - - -
# Dif | - - - - - - - -
# Metric | - - - - - - - -
# Spacegroup | - - - - - - - -
#
#
# % | Symmetry Transformation Transgen Coset Pos Dif Metric Spacegroup
# ---------------------------------------------------------------------------------------------
# Symmetry | - - Symmetry - - - - -
# Transformation | - - - - - - - -
# Transgen | - - - - - - - -
# Coset | - - Coset - - - - -
# Pos | - - Pos - - - - -
# Dif | - - Dif - - - - -
# Metric | - - - - - - - -
# Spacegroup | - - Spacegroup - - - - -
# Coset needs some pow()-declarations, so first I test everything else:
symmetry = geo.Symmetry(nb.Matrix([[-1, 0, 0, 0],
[0, -1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]]))
transformation = geo.Transformation(nb.Matrix([[0, 1, 0, 0],
[1, 0, 0, 0],
[0, 0, 2, 0],
[0, 0, 0, 1]]))
transgen = geo.canonical
pos = geo.Pos(nb.Matrix([[1], [2], [3], [1]]))
dif = geo.Dif(nb.Matrix([[4], [5], [6], [0]]))
metric = geo.Metric(nb.Matrix([[4, 0, 0, 0],
[0, 9, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]]))
spacegroup = geo.Spacegroup(geo.canonical,
[geo.Coset(geo.Symmetry(nb.Matrix.onematrix(4)), geo.canonical),
geo.Coset(geo.Symmetry(nb.Matrix([[-1, 0, 0, 0],
[0, -1, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]])), geo.canonical)])
# * :
#====
# symmetry * symmetry:
assert isinstance(symmetry * symmetry, geo.Symmetry)
# transformation * transformation
assert isinstance(transformation * transformation, geo.Transformation)
# **:
#====
# symmetry ** pos:
assert isinstance(symmetry ** pos, geo.Pos)
# symmetry ** dif:
assert isinstance(symmetry ** dif, geo.Dif)
# transformation ** symmetry:
assert isinstance(transformation ** symmetry, geo.Symmetry)
# transformation ** transgen:
assert isinstance(transformation ** transgen, geo.Transgen)
# transformation ** pos:
assert isinstance(transformation ** pos, geo.Pos)
# transformation ** dif:
assert isinstance(transformation ** dif, geo.Dif)
# transformation ** metric:
assert isinstance(transformation ** metric, geo.Metric)
# transformation ** spacegroup:
assert isinstance(transformation ** spacegroup, geo.Spacegroup)
# %:
#===
# symmetry % transgen:
assert isinstance(symmetry % transgen, geo.Symmetry)
# pos % transgen:
assert isinstance(pos % transgen, geo.Pos)
transgen1 = geo.Transgen(geo.Dif(nb.Matrix([[1], [0], [0], [0]])),
geo.Dif(nb.Matrix([[0], [1], [0], [0]])),
geo.Dif(nb.Matrix([[0], [0], [2], [0]])))
pos1 = geo.Pos(nb.Matrix([[0], [0], [fr.Fraction(3, 2)], [1]]))
pos1_ = geo.Pos(nb.Matrix([[0], [0], [fr.Fraction(3, 2)], [1]]))
assert pos1 % transgen1 == pos1_
transgen1 = geo.Transgen(geo.Dif(nb.Matrix([[0], [0], [2], [0]])),
geo.Dif(nb.Matrix([[0], [1], [0], [0]])),
geo.Dif(nb.Matrix([[1], [0], [0], [0]])))
pos1 = geo.Pos(nb.Matrix([[0], [0], [fr.Fraction(3, 2)], [1]]))
pos1_ = geo.Pos(nb.Matrix([[0], [0], [fr.Fraction(3, 2)], [1]]))
assert pos1 % transgen1 == pos1_
# dif % transgen:
assert isinstance(dif % transgen, geo.Dif)
transgen1 = geo.Transgen(geo.Dif(nb.Matrix([[0], [0], [2], [0]])),
geo.Dif(nb.Matrix([[0], [1], [0], [0]])),
geo.Dif(nb.Matrix([[1], [0], [0], [0]])))
dif1 = geo.Dif(nb.Matrix([[0], [0], [fr.Fraction(3, 2)], [0]]))
dif1_ = geo.Dif(nb.Matrix([[0], [0], [fr.Fraction(3, 2)], [0]]))
assert dif1 % transgen1 == dif1_
# spacegroup % transgen:
assert isinstance(spacegroup % transgen, geo.Spacegroup)
# Here comes Coset:
#==================
coset = geo.Coset(symmetry, transgen)
# coset * coset:
assert isinstance(coset * coset, geo.Coset)
# coset ** pos:
assert isinstance(coset ** pos, geo.Pos)
# coset ** dif:
assert isinstance(coset ** dif, geo.Dif)
# coset % transgen:
assert isinstance(coset % transgen, geo.Coset)
transgen1 = geo.Transgen(geo.Dif(nb.Matrix([[0], [0], [2], [0]])),
geo.Dif(nb.Matrix([[0], [1], [0], [0]])),
geo.Dif(nb.Matrix([[1], [0], [0], [0]])))
coset1 = geo.Coset(geo.Symmetry(nb.Matrix([[1, 0, 0, fr.Fraction(3, 2)],
[0, 1, 0, fr.Fraction(3, 2)],
[0, 0, 1, fr.Fraction(7, 2)],
[0, 0, 0, 1]])), transgen1)
coset1_ = geo.Coset(geo.Symmetry(nb.Matrix([[1, 0, 0, fr.Fraction(1, 2)],
[0, 1, 0, fr.Fraction(1, 2)],
[0, 0, 1, fr.Fraction(3, 2)],
[0, 0, 0, 1]])), transgen1)
assert coset1 % transgen1 == coset1_
def test_Coset():
g = geo.Symmetry(nb.Matrix([[1, 0, 2, -1],
[0, -2, 0, 0],
[0, 0, 1, 1],
[0, 0, 0, 1]]))
tg = geo.Transgen(geo.Dif(nb.Matrix([[1], [0], [0], [0]])),
geo.Dif(nb.Matrix([[0], [1], [0], [0]])),
geo.Dif(nb.Matrix([[0], [0], [2], [0]])))
tg1 = geo.Transgen(geo.Dif(nb.Matrix([[1], [0], [0], [0]])),
geo.Dif(nb.Matrix([[0], [1], [0], [0]])),
geo.Dif(nb.Matrix([[0], [0], [2], [0]])))
assert tg == tg1
c = geo.Coset(g, tg)
assert c.__str__() == \
"{x+2z,-2y,z+1}\n"\
" 1 0 0 \n"\
" 0 1 0 \n"\
" 0 0 2 "
c = geo.Coset(g, geo.canonical)
assert c.__str__() == "{x+2z,-2y,z}"
g = geo.Symmetry(nb.Matrix([[ 1, 0, 0, 0.5],
[ 0, 1, 0, 0],
[ 0, 0, 1, 0],
[ 0, 0, 0, 1]]))
c = geo.Coset(g, geo.canonical)
g2 = geo.Symmetry(nb.Matrix([[ 1, 0, 0, -0.5],
[ 0, 1, 0, 0],
[ 0, 0, 1, 0],
[ 0, 0, 0, 1]]))
p1 = geo.Pos(nb.Matrix([[0.3], [0], [0], [1]]))
p2 = geo.Pos(nb.Matrix([[0.8], [0], [0], [1]]))
assert c.coset_representant_for_pos(p1) == g
assert c.coset_representant_for_pos(p2) == g2
def test_fromstr():
string = "1/2"
assert isinstance(fs(string), nb.Mixed)
assert fs(string) == nb.Mixed(fr.Fraction(1, 2))
string = "1.2+/-0.1"
assert fs(string).value.n == nb.Mixed(uc.ufloat(1.2, 0.1)).value.n
assert fs(string).value.s == nb.Mixed(uc.ufloat(1.2, 0.1)).value.s
string = "1.2(1)"
assert fs(string).value.n == nb.Mixed(uc.ufloat(1.2, 0.1)).value.n
assert fs(string).value.s == nb.Mixed(uc.ufloat(1.2, 0.1)).value.s
string = "4"
assert fs(string) == nb.Mixed(fr.Fraction(4, 1))
string = "4.5"
assert fs(string) == nb.Mixed(4.5)
string = "1 2 3"
assert fromstr.typefromstr(string) == nb.Matrix
assert fs(string) == nb.Matrix([[1, 2, 3]])
string = "/ 1 2 \ \n \ 3 4 /"
assert fs(string) == \
nb.Matrix([nb.Row([nb.Mixed(1), nb.Mixed(2)]),
nb.Row([nb.Mixed(3), nb.Mixed(4)])])
string = "1 2 \n 3 4"
assert fs(string) == \
nb.Matrix([nb.Row([nb.Mixed(1), nb.Mixed(2)]),
nb.Row([nb.Mixed(3), nb.Mixed(4)])])
string = "x+y,y - x +1/3,2z"
g = fs(string)
assert g == geo.Symmetry(
fs("/ 1 1 0 0 \n"
" -1 1 0 1/3 \n"
" 0 0 2 0 \n"
" 0 0 0 1"))
string = "O->(0,0,0)\n" \
"then\n" \
"a' = a-b \n" \
"b' = b+a \n" \
"c' = 2c"
g = fs(string)
assert g == geo.Transformation(
fs(" 1 1 0 0 \n"
"-1 1 0 0 \n"
" 0 0 2 0 \n"
" 0 0 0 1").inv())
string = "O->(0,0,0) \n" \
"then\n" \
"a' = c \n" \
"b' = a \n" \
"c' = b"
g = fs(string)
assert g == geo.Transformation(
fs("0 1 0 0 \n"
"0 0 1 0 \n"
"1 0 0 0 \n"
"0 0 0 1").inv())
string = "O -> (1/2, 0, 0) \n" \
"then\n" \
"a' = a \n" \
"b' = b \n" \
"c' = c"
g = fs(string)
assert g == geo.Transformation(
fs("1 0 0 -1/2 \n"
"0 1 0 0 \n"
"0 0 1 0 \n"
"0 0 0 1"))
string1 = "O -> (1/2, 0, 0) \n" \
"then\n" \
"a' = a \n" \
"b' = b \n" \
"c' = c"
string2 = "O -> (0,0,0) \n" \
"then\n" \
"a' = b\n" \
"b' = a\n" \
"c' = c"
string = "O -> (1/2, 0, 0) \n" \
"then\n"\
"a' = b\n"\
"b' = a\n"\
"c' = c"
g1 = fs(string1)
g2 = fs(string2)
g = fs(string)
assert g == g2 * g1
string = "O -> (1/2, 0, 0) \n" \
"then\n" \
"a' = a + b\n" \
"b' = b\n" \
"c' = c"
print("--------")
g = fs(string)
print(g.value)
assert g**fs("p 1/2 0 0") == fs("p 0 0 0")
assert g**fs("p 1/2 1/3 0") == fs("p 0 1/3 0")
assert g**fs("p 0 0 0") == fs("p -1/2 1/2 0")
assert g * g.inv() == geo.Transformation(nb.Matrix.onematrix(4))
string = "p0 0 0"
p = fs(string)
assert p == geo.Pos(fs("0 \n 0 \n 0 \n 1"))
string = "P0 0 0"
p = fs(string)
assert p == geo.Pos(fs("0 \n 0 \n 0 \n 1"))
string = "r0 0 0"
p = fs(string)
assert p == geo.Pos(fs("0 \n 0 \n 0 \n 1"))
string = "R0 0 0"
p = fs(string)
assert p == geo.Pos(fs("0 \n 0 \n 0 \n 1"))
string = p.__str__()
assert string == "Pos / 0 \ \n" \
" | 0 |\n" \
" \ 0 / "
p1 = fs(string)
assert p == p1
string = "R1/2 1/2 1/2"
p = fs(string)
assert p == geo.Pos(fs("1/2 \n 1/2 \n 1/2 \n 1"))
q = fs("k1 2 3")
assert q == geo.Rec(fs("1 2 3 0"))
q = fs("K 1 2 3")
assert q == geo.Rec(fs("1 2 3 0"))
q = fs("q 1/2 1/2 0")
assert q == geo.Rec(fs("1/2 1/2 0 0"))
q = fs("Q0 0 0")
assert q == geo.Rec(fs("0 0 0 0"))
q = fs("Rec < 1 2 3 > ")
assert q == geo.Rec(fs("1 2 3 0"))
def test_Matrix():
# create and shape
M1 = nb.Matrix([nb.Row([1, 2, 3]), nb.Row([4, 5, 6])])
M2 = nb.Matrix([[1, 2, 3], [4, 5, 6]])
assert M1.shape() == (2, 3)
assert M2.shape() == (2, 3)
# Equal
M1 = nb.Matrix([nb.Row([1, 2, 3]), nb.Row([4, 5, 6])])
M2 = nb.Matrix([[1, 2, 3], [4, 5, 6]])
M3 = nb.Matrix([[1, 2, 3], [4, 5.1, 6]])
M4 = nb.Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
M5 = nb.Matrix([[1, 2], [4, 5]])
M6 = nb.Matrix([[1, 2, 3], [4, 5.0, 6]])
M7 = nb.Matrix([[1, 2, 3], [4, fr.Fraction(5, 1), 6]])
assert M1 == M2
assert (M1 == M3) == False
assert (M1 == M4) == False
assert (M1 == M5) == False
assert (M1 == M6) == False
assert M1 == M7
M1 = nb.Matrix([nb.Row([1, 2, 3.0]), nb.Row([4, 5, 6])])
M2 = nb.Matrix([nb.Row([1, 2, 2.999999999999]), nb.Row([4, 5, 6])])
print(hash(M1))
print(hash(M2))
assert hash(M1) == hash(M2)
e = uc.ufloat(1.2, 0.1)
M1 = nb.Matrix([nb.Row([1, 2, e]), nb.Row([4, 5, 6])])
M2 = nb.Matrix([nb.Row([1, 2, e]), nb.Row([4, 5, 6])])
M3 = nb.Matrix([nb.Row([1, 2, uc.ufloat(1.2, 0.1)]), nb.Row([4, 5, 6])])
assert M1 == M2
assert (M1 == M3) == False
assert hash(M1) == hash(M2)
assert (hash(M1) == hash(M3)) == False
# print
assert nb.Matrix([[1, 2]]).__str__() == " < 1 2 > "
assert nb.Matrix([[1, 2], [3, 4]]).__str__() == " / 1 2 \ \n" \
" \ 3 4 / "
assert nb.Matrix([[1, 2, 3], [4, 5, 6], [7, 800, 9]]).__str__() == \
" / 1 2 3 \ \n" \
"| 4 5 6 |\n" \
" \ 7 800 9 / "
# Addition
assert nb.Matrix([[1, 2], [3, 4]]) + nb.Matrix([[5, 6], [7, 8]]) == \
nb.Matrix([[6, 8], [10, 12]])
assert nb.Matrix([[1, 2], [3, 4], [5, 6]]) + \
nb.Matrix([[1, 1], [1, 1], [1, 1]]) == \
nb.Matrix([[2, 3], [4, 5], [6, 7]])
# Subtraction
assert nb.Matrix([[1, 2], [3, 4]]) - nb.Matrix([[5, 6], [7, 8]]) == \
nb.Matrix([[-4, -4], [-4, -4]])
assert nb.Matrix([[1, 2], [3, 4], [5, 6]]) - \
nb.Matrix([[1, 1], [1, 1], [1, 1]]) == \
nb.Matrix([[0, 1], [2, 3], [4, 5]])
# neg
M1 = nb.Matrix([[1, 2, 3], [4, 5, 6]])
assert -M1 == nb.Matrix([[-1, -2, -3], [-4, -5, -6]])
# Multiplication "Matrix * Matrix"
M1 = nb.Matrix([[1, 2], [3, 4]])
M2 = nb.Matrix([[5, 6], [7, 8]])
assert isinstance(M1 * M2, nb.Matrix)
assert M1 * M2 == nb.Matrix([[19, 22], [43, 50]])
M1 = nb.Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
M2 = nb.Matrix([[uc.ufloat(1.2, 0.1)], [1], [2]])
print(M2)
print(M1*M2)
assert (M1 * M2).liste[1].liste[0] == M2.liste[1].liste[0]
assert M1 * M2 == M2
# Multiplication "Scalar * Matrix"
M1 = nb.Matrix([[1, 2], [3, 4]])
assert M1 * nb.Mixed(fr.Fraction(1, 2)) == \
nb.Matrix([[fr.Fraction(1, 2), 1], [fr.Fraction(3, 2), 2]])
assert M1 * fr.Fraction(1, 2) == \
nb.Matrix([[fr.Fraction(1, 2), 1], [fr.Fraction(3, 2), 2]])
assert nb.Mixed(fr.Fraction(1, 2)) * M1 == \
nb.Matrix([[fr.Fraction(1, 2), 1], [fr.Fraction(3, 2), 2]])
assert fr.Fraction(1, 2) * M1 == \
nb.Matrix([[fr.Fraction(1, 2), 1], [fr.Fraction(3, 2), 2]])
M = M1 * nb.Mixed(uc.ufloat(1.2, 0.1))
assert approx(M.liste[0].liste[0].value.n, 1.2)
assert approx(M.liste[0].liste[0].value.s, 0.1)
assert approx(M.liste[0].liste[1].value.n, 2.4)
assert approx(M.liste[0].liste[1].value.s, 0.2)
assert approx(M.liste[1].liste[0].value.n, 3.6)
assert approx(M.liste[1].liste[0].value.s, 0.3)
assert approx(M.liste[1].liste[1].value.n, 4.8)
assert approx(M.liste[1].liste[1].value.s, 0.4)
M = M1 * uc.ufloat(1.2, 0.1)
assert approx(M.liste[0].liste[0].value.n, 1.2)
assert approx(M.liste[0].liste[0].value.s, 0.1)
assert approx(M.liste[0].liste[1].value.n, 2.4)
assert approx(M.liste[0].liste[1].value.s, 0.2)
assert approx(M.liste[1].liste[0].value.n, 3.6)
assert approx(M.liste[1].liste[0].value.s, 0.3)
assert approx(M.liste[1].liste[1].value.n, 4.8)
assert approx(M.liste[1].liste[1].value.s, 0.4)
M = nb.Mixed(uc.ufloat(1.2, 0.1)) * M1
assert approx(M.liste[0].liste[0].value.n, 1.2)
assert approx(M.liste[0].liste[0].value.s, 0.1)
assert approx(M.liste[0].liste[1].value.n, 2.4)
assert approx(M.liste[0].liste[1].value.s, 0.2)
assert approx(M.liste[1].liste[0].value.n, 3.6)
assert approx(M.liste[1].liste[0].value.s, 0.3)
assert approx(M.liste[1].liste[1].value.n, 4.8)
assert approx(M.liste[1].liste[1].value.s, 0.4)
M = uc.ufloat(1.2, 0.1) * M1
assert approx(M.liste[0].liste[0].value.n, 1.2)
assert approx(M.liste[0].liste[0].value.s, 0.1)
assert approx(M.liste[0].liste[1].value.n, 2.4)
assert approx(M.liste[0].liste[1].value.s, 0.2)
assert approx(M.liste[1].liste[0].value.n, 3.6)
assert approx(M.liste[1].liste[0].value.s, 0.3)
assert approx(M.liste[1].liste[1].value.n, 4.8)
assert approx(M.liste[1].liste[1].value.s, 0.4)
assert M1 * nb.Mixed(2) == nb.Matrix([[2, 4], [6, 8]])
assert M1 * 2 == nb.Matrix([[2, 4], [6, 8]])
assert nb.Mixed(2) * M1 == nb.Matrix([[2, 4], [6, 8]])
assert 2 * M1 == nb.Matrix([[2, 4], [6, 8]])
M = M1 * nb.Mixed(2.5)
assert approx(M.liste[0].liste[0].value, 2.5)
assert approx(M.liste[0].liste[1].value, 5.0)
assert approx(M.liste[1].liste[0].value, 7.5)
assert approx(M.liste[1].liste[1].value, 10.0)
M = M1 * 2.5
assert approx(M.liste[0].liste[0].value, 2.5)
assert approx(M.liste[0].liste[1].value, 5.0)
assert approx(M.liste[1].liste[0].value, 7.5)
assert approx(M.liste[1].liste[1].value, 10.0)
M = nb.Mixed(2.5) * M1
assert approx(M.liste[0].liste[0].value, 2.5)
assert approx(M.liste[0].liste[1].value, 5.0)
assert approx(M.liste[1].liste[0].value, 7.5)
assert approx(M.liste[1].liste[1].value, 10.0)
M = 2.5 * M1
assert approx(M.liste[0].liste[0].value, 2.5)
assert approx(M.liste[0].liste[1].value, 5.0)
assert approx(M.liste[1].liste[0].value, 7.5)
assert approx(M.liste[1].liste[1].value, 10.0)
# onematrix
assert nb.Matrix.onematrix(2) == nb.Matrix([[1, 0], [0, 1]])
assert nb.Matrix.onematrix(3) == nb.Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
# block
M = nb.Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
assert M.block(0, 2, 0, 2) == nb.Matrix([[1, 2], [4, 5]])
assert M.block(1, 2, 0, 3) == nb.Matrix([[4, 5, 6]])
M = nb.Matrix([[1, 2, 3, 4]])
assert M.block(0, 1, 0, 3) == nb.Matrix([[1, 2, 3]])
# swap_rows
M = nb.Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
assert M.swap_rows(0, 1) == nb.Matrix([[4, 5, 6], [1, 2, 3], [7, 8, 9]])
# vglue
M1 = nb.Matrix([[1, 2, 3]])
M2 = nb.Matrix([[4, 5, 6]])
assert nb.Matrix.vglue(M1, M2) == nb.Matrix([[1, 2, 3], [4, 5, 6]])
# subtract_x_times_rowj_from_rowi
M = nb.Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
assert M.subtract_x_times_rowj_from_rowi(2, 2, 0) == \
nb.Matrix([[1, 2, 3], [4, 5, 6], [5, 4, 3]])
# inv
assert nb.Matrix([[2, 3],
[4, 5]]).inv() == \
nb.Matrix([[-fr.Fraction(5, 2), fr.Fraction(3, 2)],
[2, -1]])
assert nb.Matrix([[0, 1, 1],
[1, 0, 0],
[0, 0, -1]]).inv() == \
nb.Matrix([[0, 1, 0],
[1, 0, 1],
[0, 0, -1]])
assert nb.Matrix([[0, 0, 1, 0],
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 0, 1]]).inv() == \
nb.Matrix([[0, 1, 0, 0],
[0, 0, 1, 0],
[1, 0, 0, 0],
[0, 0, 0, 1]])
# transpose
assert nb.Matrix([[1, 2, 3], [4, 5, 6]]).transpose() == \
nb.Matrix([[1, 4], [2, 5], [3, 6]])
# delete_ith_row_and_first_column
M = nb.Matrix([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
assert M.delete_ith_row_and_first_column(1) == nb.Matrix([[2, 3, 4],
[10, 11, 12]])
# det
M = nb.Matrix([[3]])
assert M.det() == 3
M = nb.Matrix([[1, 2],
[3, 4]])
assert M.det() == -2
M = nb.Matrix([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
assert M.det() == 0
M = nb.Matrix([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 8, 11, 12],
[13, 14, 15, 17]])
assert M.det() == -16
# delete_translation
M = nb.Matrix([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[0, 0, 0, 1]])
assert M.delete_translation() == nb.Matrix([[1, 2, 3, 0],
[5, 6, 7, 0],
[9, 10, 11, 0],
[0, 0, 0, 1]])
def test_Pointgroup():
pg = geo.Pointgroup([geo.Symmetry(nb.Matrix([[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[-1, 0, 0, 0],
[0, -1, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]]))])
assert isinstance(pg, geo.Pointgroup)
assert pg.__str__() == "Pointgroup\n" \
"==========\n" \
"x,y,z\n" \
"-x,-y,-z\n"
assert pg.is_really_a_pointgroup()
pg1 = geo.Pointgroup([geo.Symmetry(nb.Matrix([[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[-1, 0, 0, 0],
[0, -1, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]]))])
pg2 = geo.Pointgroup([geo.Symmetry(nb.Matrix([[-1, 0, 0, 0],
[0, -1, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]]))])
assert pg == pg1
assert not (pg == pg2)
assert not (pg == 2)
assert not pg2.is_really_a_pointgroup()
G = geo.Pointgroup([geo.Symmetry(nb.Matrix([[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[-1, 0, 0, 0],
[0, -1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[-1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[1, 0, 0, 0],
[0, -1, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[0, 1, 0, 0],
[1, 0, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[0, -1, 0, 0],
[-1, 0, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[0, -1, 0, 0],
[1, 0, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[0, 1, 0, 0],
[-1, 0, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[-1, 0, 0, 0],
[0, -1, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[1, 0, 0, 0],
[0, -1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[-1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[0, -1, 0, 0],
[-1, 0, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[0, 1, 0, 0],
[1, 0, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[0, 1, 0, 0],
[-1, 0, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[0, -1, 0, 0],
[1, 0, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]]))])
assert G.is_really_a_pointgroup()
g = G.liste
# For this test, the order of the symmetry elements must not be
# completely arbitrary, because there are several valid possibilities
# to sort the symmetryelements.
G1 = geo.Pointgroup([g[6], g[7], g[0], g[14], g[15], g[9], g[10], g[11],
g[12], g[13], g[8], g[1], g[2], g[3], g[4], g[5]])
print(G1.sort())
print(G)
assert G1.sort() == G
H = geo.Pointgroup([geo.Symmetry(nb.Matrix([[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[-1, 0, 0, 0],
[0, -1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[0, -1, 0, 0],
[1, 0, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[0, 1, 0, 0],
[-1, 0, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[-1, 0, 0, 0],
[0, -1, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[0, 1, 0, 0],
[-1, 0, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]])),
geo.Symmetry(nb.Matrix([[0, -1, 0, 0],
[1, 0, 0, 0],
[0, 0, -1, 0],
[0, 0, 0, 1]]))])
assert H.is_really_a_pointgroup()
assert G1.coset_decomposition_with_respect_to(H) \
== "x,y,z\n" \
"-x,y,-z\n"
def test_Transformation():
t1 = geo.Transformation(nb.Matrix([[0, 1, 0, 0],
[1, 0, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]]))
assert t1.__str__() == "Transformation O -> (0, 0, 0)\n" \
" then\n" \
" a' = b\n" \
" b' = a\n" \
" c' = c"
t2 = geo.Transformation(nb.Matrix([[1, 0, 0, fr.Fraction(1, 2)],
[0, 1, 0, fr.Fraction(1, 4)],
[0, 0, 1, fr.Fraction(1, 3)],
[0, 0, 0, 1]]))
assert t2.__str__() == "Transformation O -> (-1/2, -1/4, -1/3)\n" \
" then\n" \
" a' = a\n" \
" b' = b\n" \
" c' = c"
assert isinstance(t2.inv(), geo.Transformation)
assert t2 * t2.inv() == geo.Transformation(nb.Matrix.onematrix(4))
t3 = geo.Transformation(nb.Matrix([[1.0, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]]))
print(t3.value)
assert t3.__str__() == "Transformation O -> (0, 0, 0)\n" \
" then\n" \
" a' = 1.0a\n" \
" b' = b\n" \
" c' = c"
q1 = geo.Rec(nb.Matrix([[1, 0, 0, 0]]))
t = geo.Transformation(nb.Matrix([[0, 1, 0, 0],
[0, 0, 1, 0],
[1, 0, 0, 0],
[0, 0, 0, 1]]))
assert isinstance(t ** q1, geo.Rec)
assert (t ** q1) == geo.Rec(nb.Matrix([[0, 0, 1, 0]]))
q1 = geo.Rec(nb.Matrix([[1, 0, 0, 0]]))
t = geo.Transformation(nb.Matrix([[0, 1, 0, 0.3],
[0, 0, 1, 0.7],
[1, 0, 0, 100],
[0, 0, 0, 1]]))
assert isinstance(t ** q1, geo.Rec)
assert (t ** q1) == geo.Rec(nb.Matrix([[0, 0, 1, 0]]))
q1 = geo.Rec(nb.Matrix([[0, 0, 1, 0]]))
t = geo.Transformation(nb.Matrix([[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 2, 0],
[0, 0, 0, 1]]))
assert t.__str__() == "Transformation O -> (0, 0, 0)\n" \
" then\n" \
" a' = a\n" \
" b' = b\n" \
" c' = 1/2c"
assert isinstance(t ** q1, geo.Rec)
assert (t ** q1) == \
geo.Rec(nb.Matrix([[0, 0, nb.Mixed(fr.Fraction(1, 2)), 0]]))
q1 = geo.Rec(nb.Matrix([[0, 0, 1, 0]]))
t = geo.Transformation(nb.Matrix([[1, 0, 0, 0],
[0, 0, 2, 0],
[0, -1, 0, 0],
[0, 0, 0, 1]]))
assert t.__str__() == "Transformation O -> (0, 0, 0)\n" \
" then\n" \
" a' = a\n" \
" b' = 1/2c\n" \
" c' = -b"
assert isinstance(t ** q1, geo.Rec)
print(t)
assert (t ** q1) == \
geo.Rec(nb.Matrix([[0, nb.Mixed(fr.Fraction(1, 2)), 0, 0]]))
def transformationfromstr(string):
if len(string.split("then")) > 1:
# The string respresents not an elementar transformation,
# i.e. the string represents a transformation which is
# a composition of elementar transformations.
result = geo.Transformation(nb.Matrix.onematrix(4))
for word in string.split("\nthen\n"):
result = transformationfromstr(word) * result
return result
else:
# The string represents an elementar transformation,
# i.e. either a pure translation of the origin or a
# pure change of the axes.
if ('O' in string) or ("->" in string):
# The string represents a pure translation of the origin.
words = string.split("->")
word = words[1]
word = word.replace('\n', ' ')
word = word.replace('(', ' ').replace(')', ' ').replace(',', ' ')
threenumbers = fromstr(word)
matrix = nb.Matrix([[1, 0, 0, -threenumbers.liste[0].liste[0]],
[0, 1, 0, -threenumbers.liste[0].liste[1]],
[0, 0, 1, -threenumbers.liste[0].liste[2]],
[0, 0, 0, 1]])
return geo.Transformation(matrix)
elif ('a' in string) or ('b' in string) or ('c' in string):
# The string represents a pure change of the axes
lines = string.split('\n')
assert len(lines) == 3, \
"The following string looks like a Transformation, " \
"but it has not exactly three lines: %s" % (string)
liste = []
i = 0
for line in lines:
if len(line.split(' ')) > 0:
i += 1
words = line.split(' ')
assert ( ((i == 1) and (words[0] == "a'"))
or ((i == 2) and (words[0] == "b'"))
or ((i == 3) and (words[0] == "c'")) )\
and (words[1] == '='), \
"The Transformation must have the following form: \n" \
"a' = ... \n" \
"b' = ... \n" \
"c' = ... \n" \
"in this Order!"
words = line.split('=')
row = nb.Row(str2linearterm(words[1], ['a', 'b', 'c']))
liste.append(row)
liste.append(
nb.Row(
[fromstr("0"),
fromstr("0"),
fromstr("0"),
fromstr("1")]))
m = nb.Matrix(liste)
matrix = nb.Matrix([
nb.Row([
m.liste[0].liste[0], m.liste[1].liste[0],
m.liste[2].liste[0], 0
]),
nb.Row([
m.liste[0].liste[1], m.liste[1].liste[1],
m.liste[2].liste[1], 0
]),
nb.Row([
m.liste[0].liste[2], m.liste[1].liste[2],
m.liste[2].liste[2], 0
]),
nb.Row([0, 0, 0, 1])
])
return geo.Transformation(matrix.inv())
def test_Metric():
M = nb.Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
metric = geo.Metric(M)
t = metric.schmidttransformation
assert t**geo.canonical_e0 == geo.Dif(nb.Matrix([[1], [0], [0], [0]]))
assert t**geo.canonical_e1 == geo.Dif(nb.Matrix([[0], [1], [0], [0]]))
assert t**geo.canonical_e2 == geo.Dif(nb.Matrix([[0], [0], [1], [0]]))
metric = geo.Cellparameters(1, 1, 1, 90, 90, 45).to_Metric()
t = metric.schmidttransformation
assert t**geo.canonical_e0 == geo.Dif(nb.Matrix([[1], [0], [0], [0]]))
e1 = t**geo.canonical_e1
assert abs(e1.x() - 0.70710678).value < 0.000001
assert abs(e1.y() - 0.70710678).value < 0.000001
assert abs(e1.z() - 0).value < 0.000001
e2 = t**geo.canonical_e2
assert abs(e2.x() - 0).value < 0.000001
assert abs(e2.y() - 0).value < 0.000001
assert abs(e2.z() - 1).value < 0.000001
t = metric.schmidttransformation.inv()
M = nb.Matrix([[9, 0, 0, 0], [0, 4, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
metric = geo.Metric(M)
assert metric.__str__() == "Metric / 9 0 0 0 \ \n" \
" | 0 4 0 0 |\n" \
" | 0 0 1 0 |\n" \
" \ 0 0 0 1 / "
o = geo.Pos(nb.Matrix([[0], [0], [0], [1]]))
p1 = geo.Pos(nb.Matrix([[1], [0], [0], [1]]))
p2 = geo.Pos(nb.Matrix([[0], [1], [0], [1]]))
q1 = geo.Rec(nb.Matrix([[1, 0, 0, 0]]))
q2 = geo.Rec(nb.Matrix([[0, 1, 0, 0]]))
q3 = geo.Rec(nb.Matrix([[1, 1, 0, 0]]))
assert metric.dot(p1 - o, p1 - o).__str__() == "9"
assert metric.dot(p1 - o, p2 - o).__str__() == "0"
assert metric.dot(q1, q1).__str__() == "1/9"
assert metric.dot(q2, q2).__str__() == "1/4"
assert metric.dot(q3, q3).__str__() == "13/36"
assert metric.length(p1 - o) == 3
assert abs(float(
(metric.angle(p1 - o, p2 - o) - nb.deg2rad(90)))) < 0.00001
assert metric.length(q1).__str__() == "1/3"
assert abs(float((metric.angle(q1, q2) - nb.deg2rad(90)))) < 0.00001
assert metric.angle(p1 - o, p1 - o).__str__() == "0.0"
assert metric.angle(q1, q1).__str__() == "0.0"
metric = geo.Cellparameters(4.15, 4.15, 28.64, 90, 90, 120).to_Metric()
M = nb.Matrix([[9, 0, 0, 0], [0, 4, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
metric = geo.Metric(M)
cell = metric.to_Cellparameters()
assert cell.__str__() == \
geo.Cellparameters(3, 2, 1, 90.0, 90.0, 90.0).__str__()
t = geo.Transformation(
nb.Matrix([[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 1, 0.5], [0, 0, 0, 1]]))
assert t**metric == geo.Metric(
nb.Matrix([[4, 0, 0, 0], [0, 9, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]))
