def testinterplanarangle_triclinic(self):
lat = self.triclinic
s11 = lat.b ** 2 * lat.c ** 2 * sin(lat.alpha) ** 2
s22 = lat.a ** 2 * lat.c ** 2 * sin(lat.beta) ** 2
s33 = lat.a ** 2 * lat.b ** 2 * sin(lat.gamma) ** 2
s12 = lat.a * lat.b * lat.c ** 2 * (cos(lat.alpha) * cos(lat.beta) - cos(lat.gamma))
s23 = lat.a ** 2 * lat.b * lat.c * (cos(lat.beta) * cos(lat.gamma) - cos(lat.alpha))
s13 = lat.a * lat.b ** 2 * lat.c * (cos(lat.gamma) * cos(lat.alpha) - cos(lat.beta))
v = lat.a * lat.b * lat.c * sqrt(1 - cos(lat.alpha) ** 2 - \
cos(lat.beta) ** 2 - \
cos(lat.gamma) ** 2 + \
2 * cos(lat.alpha) * cos(lat.beta) * cos(lat.gamma))
equation = lambda lat, h1, k1, l1, h2, k2, l2: \
d1 * d2 / v ** 2 * (s11 * h1 * h2 + \
s22 * k1 * k2 + \
s33 * l1 * l2 + \
s23 * (k1 * l2 + k2 * l1) + \
s13 * (l1 * h2 + l2 * h1) + \
s12 * (h1 * k2 + h2 * k1))
for plane1 in self.planes:
for plane2 in self.planes:
d1 = calculations.planespacing(plane1, self.triclinic)
d2 = calculations.planespacing(plane2, self.triclinic)
angle = calculations.interplanarangle(plane1, plane2, self.triclinic)
args = copy.deepcopy(plane1)
args.extend(plane2)
expected_angle = acos(equation(self.triclinic, *args))
self.assertAlmostEqual(angle, expected_angle, 6)
def testinterplanarangle_triclinic(self):
lat = self.triclinic
s11 = lat.b**2 * lat.c**2 * sin(lat.alpha)**2
s22 = lat.a**2 * lat.c**2 * sin(lat.beta)**2
s33 = lat.a**2 * lat.b**2 * sin(lat.gamma)**2
s12 = lat.a * lat.b * lat.c**2 * (cos(lat.alpha) * cos(lat.beta) -
cos(lat.gamma))
s23 = lat.a**2 * lat.b * lat.c * (cos(lat.beta) * cos(lat.gamma) -
cos(lat.alpha))
s13 = lat.a * lat.b**2 * lat.c * (cos(lat.gamma) * cos(lat.alpha) -
cos(lat.beta))
v = lat.a * lat.b * lat.c * sqrt(1 - cos(lat.alpha) ** 2 - \
cos(lat.beta) ** 2 - \
cos(lat.gamma) ** 2 + \
2 * cos(lat.alpha) * cos(lat.beta) * cos(lat.gamma))
equation = lambda lat, h1, k1, l1, h2, k2, l2: \
d1 * d2 / v ** 2 * (s11 * h1 * h2 + \
s22 * k1 * k2 + \
s33 * l1 * l2 + \
s23 * (k1 * l2 + k2 * l1) + \
s13 * (l1 * h2 + l2 * h1) + \
s12 * (h1 * k2 + h2 * k1))
for plane1 in self.planes:
for plane2 in self.planes:
d1 = calculations.planespacing(plane1, self.triclinic)
d2 = calculations.planespacing(plane2, self.triclinic)
angle = calculations.interplanarangle(plane1, plane2,
self.triclinic)
args = copy.deepcopy(plane1)
args.extend(plane2)
expected_angle = acos(equation(self.triclinic, *args))
self.assertAlmostEqual(angle, expected_angle, 6)
def _compute_reflectors(self):
reflectors = set()
indices_range = range(-self._maxindice, self._maxindice + 1)
for h in indices_range:
for k in indices_range:
for l in indices_range:
if h == 0 and k == 0 and l == 0: continue # Skip null plane
# Create plane
# Only look at positive planes since negative plane are equivalent
p = plane.Plane(h, k, l)
p.positive()
# Calculate the intensities
intensity = \
calculations.diffraction_intensity(p, self._unitcell,
self._atoms,
self._scatter)
maxintensity = \
calculations.diffraction_maxintensity(self._unitcell,
self._atoms,
self._scatter)
# Check if the plane diffracts
if calculations._is_diffracting(intensity, maxintensity):
planespacing = calculations.planespacing(p, self._unitcell)
reflector = Reflector(p, planespacing, intensity)
reflectors.add(reflector)
return reflectors
def testplanespacing_triclinic(self):
lat = self.triclinic
s11 = lat.b ** 2 * lat.c ** 2 * sin(lat.alpha) ** 2
s22 = lat.a ** 2 * lat.c ** 2 * sin(lat.beta) ** 2
s33 = lat.a ** 2 * lat.b ** 2 * sin(lat.gamma) ** 2
s12 = lat.a * lat.b * lat.c ** 2 * (cos(lat.alpha) * cos(lat.beta) - cos(lat.gamma))
s23 = lat.a ** 2 * lat.b * lat.c * (cos(lat.beta) * cos(lat.gamma) - cos(lat.alpha))
s13 = lat.a * lat.b ** 2 * lat.c * (cos(lat.gamma) * cos(lat.alpha) - cos(lat.beta))
v = lat.a * lat.b * lat.c * sqrt(1 - cos(lat.alpha) ** 2 - \
cos(lat.beta) ** 2 - \
cos(lat.gamma) ** 2 + \
2 * cos(lat.alpha) * cos(lat.beta) * cos(lat.gamma))
equation = lambda h, k, l: \
(1.0 / v ** 2) * (s11 * h ** 2 + \
s22 * k ** 2 + \
s33 * l ** 2 + \
2 * s12 * h * k + \
2 * s23 * k * l + \
2 * s13 * h * l)
for plane in self.planes:
spacing = calculations.planespacing(plane, self.triclinic)
expected_spacing = 1.0 / sqrt(equation(*plane))
self.assertAlmostEqual(spacing, expected_spacing)
def testplanespacing_cubic(self):
equation = lambda lat, h, k, l: (h ** 2 + k ** 2 + l ** 2) / lat.a ** 2
for plane in self.planes:
spacing = calculations.planespacing(plane, self.cubic)
expected_spacing = 1.0 / sqrt(equation(self.cubic, *plane))
self.assertAlmostEqual(spacing, expected_spacing)
def testplanespacing_triclinic(self):
lat = self.triclinic
s11 = lat.b**2 * lat.c**2 * sin(lat.alpha)**2
s22 = lat.a**2 * lat.c**2 * sin(lat.beta)**2
s33 = lat.a**2 * lat.b**2 * sin(lat.gamma)**2
s12 = lat.a * lat.b * lat.c**2 * (cos(lat.alpha) * cos(lat.beta) -
cos(lat.gamma))
s23 = lat.a**2 * lat.b * lat.c * (cos(lat.beta) * cos(lat.gamma) -
cos(lat.alpha))
s13 = lat.a * lat.b**2 * lat.c * (cos(lat.gamma) * cos(lat.alpha) -
cos(lat.beta))
v = lat.a * lat.b * lat.c * sqrt(1 - cos(lat.alpha) ** 2 - \
cos(lat.beta) ** 2 - \
cos(lat.gamma) ** 2 + \
2 * cos(lat.alpha) * cos(lat.beta) * cos(lat.gamma))
equation = lambda h, k, l: \
(1.0 / v ** 2) * (s11 * h ** 2 + \
s22 * k ** 2 + \
s33 * l ** 2 + \
2 * s12 * h * k + \
2 * s23 * k * l + \
2 * s13 * h * l)
for plane in self.planes:
spacing = calculations.planespacing(plane, self.triclinic)
expected_spacing = 1.0 / sqrt(equation(*plane))
self.assertAlmostEqual(spacing, expected_spacing)
def testplanespacing_cubic(self):
equation = lambda lat, h, k, l: (h**2 + k**2 + l**2) / lat.a**2
for plane in self.planes:
spacing = calculations.planespacing(plane, self.cubic)
expected_spacing = 1.0 / sqrt(equation(self.cubic, *plane))
self.assertAlmostEqual(spacing, expected_spacing)
def testinterplanarangle_monoclinic(self):
equation = lambda lat, h1, k1, l1, h2, k2, l2: \
d1 * d2 / sin(lat.beta) ** 2 * \
(h1 * h2 / lat.a ** 2 + \
k1 * k2 * sin(lat.beta) ** 2 / lat.b ** 2 + \
l1 * l2 / lat.c ** 2 - \
(l1 * h2 + l2 * h1) * cos(lat.beta) / (lat.a * lat.c))
for plane1 in self.planes:
for plane2 in self.planes:
d1 = calculations.planespacing(plane1, self.monoclinic)
d2 = calculations.planespacing(plane2, self.monoclinic)
angle = calculations.interplanarangle(plane1, plane2, self.monoclinic)
args = copy.deepcopy(plane1)
args.extend(plane2)
expected_angle = acos(equation(self.monoclinic, *args))
self.assertAlmostEqual(angle, expected_angle, 6)
def testplanespacing_tetragonal(self):
equation = lambda lat, h, k, l: (h ** 2 + k ** 2) / lat.a ** 2 + \
l ** 2 / lat.c ** 2
for plane in self.planes:
spacing = calculations.planespacing(plane, self.tetragonal)
expected_spacing = 1.0 / sqrt(equation(self.tetragonal, *plane))
self.assertAlmostEqual(spacing, expected_spacing)
def testplanespacing_tetragonal(self):
equation = lambda lat, h, k, l: (h ** 2 + k ** 2) / lat.a ** 2 + \
l ** 2 / lat.c ** 2
for plane in self.planes:
spacing = calculations.planespacing(plane, self.tetragonal)
expected_spacing = 1.0 / sqrt(equation(self.tetragonal, *plane))
self.assertAlmostEqual(spacing, expected_spacing)
def testinterplanarangle_monoclinic(self):
equation = lambda lat, h1, k1, l1, h2, k2, l2: \
d1 * d2 / sin(lat.beta) ** 2 * \
(h1 * h2 / lat.a ** 2 + \
k1 * k2 * sin(lat.beta) ** 2 / lat.b ** 2 + \
l1 * l2 / lat.c ** 2 - \
(l1 * h2 + l2 * h1) * cos(lat.beta) / (lat.a * lat.c))
for plane1 in self.planes:
for plane2 in self.planes:
d1 = calculations.planespacing(plane1, self.monoclinic)
d2 = calculations.planespacing(plane2, self.monoclinic)
angle = calculations.interplanarangle(plane1, plane2,
self.monoclinic)
args = copy.deepcopy(plane1)
args.extend(plane2)
expected_angle = acos(equation(self.monoclinic, *args))
self.assertAlmostEqual(angle, expected_angle, 6)
def testplanespacing_trigonal(self):
equation = lambda lat, h, k, l: \
((h ** 2 + k ** 2 + l ** 2) * sin(lat.alpha) ** 2 + \
2 * (h * k + k * l + h * l) * (cos(lat.alpha) ** 2 - cos(lat.alpha))) / \
(lat.a ** 2 * (1 - 3 * cos(lat.alpha) ** 2 + 2 * cos(lat.alpha) ** 3))
for plane in self.planes:
spacing = calculations.planespacing(plane, self.trigonal)
expected_spacing = 1.0 / sqrt(equation(self.trigonal, *plane))
self.assertAlmostEqual(spacing, expected_spacing)
def testplanespacing_trigonal(self):
equation = lambda lat, h, k, l: \
((h ** 2 + k ** 2 + l ** 2) * sin(lat.alpha) ** 2 + \
2 * (h * k + k * l + h * l) * (cos(lat.alpha) ** 2 - cos(lat.alpha))) / \
(lat.a ** 2 * (1 - 3 * cos(lat.alpha) ** 2 + 2 * cos(lat.alpha) ** 3))
for plane in self.planes:
spacing = calculations.planespacing(plane, self.trigonal)
expected_spacing = 1.0 / sqrt(equation(self.trigonal, *plane))
self.assertAlmostEqual(spacing, expected_spacing)
def testinterplanarangle_trigonal(self):
lat = self.trigonal
v = lat.a ** 3 * sqrt(1 - 3 * cos(lat.alpha) ** 2 + 2 * cos(lat.alpha) ** 3)
equation = lambda lat, h1, k1, l1, h2, k2, l2: \
(lat.a ** 4 * d1 * d2) / v ** 2 * \
(sin(lat.alpha) ** 2 * (h1 * h2 + k1 * k2 + l1 * l2) + \
(cos(lat.alpha) ** 2 - cos(lat.alpha)) * \
(k1 * l2 + k2 * l1 + l1 * h2 + l2 * h1 + h1 * k2 + h2 * k1))
for plane1 in self.planes:
for plane2 in self.planes:
d1 = calculations.planespacing(plane1, lat)
d2 = calculations.planespacing(plane2, lat)
angle = calculations.interplanarangle(plane1, plane2, self.trigonal)
args = copy.deepcopy(plane1)
args.extend(plane2)
expected_angle = acos(equation(self.trigonal, *args))
self.assertAlmostEqual(angle, expected_angle, 6)
def testplanespacing_monoclinic(self):
equation = lambda lat, h, k, l: \
(1.0 / sin(lat.beta) ** 2) * \
(h ** 2 / lat.a ** 2 +
k ** 2 * sin(lat.beta) ** 2 / lat.b ** 2 + \
l ** 2 / lat.c ** 2 - \
2 * h * l * cos(lat.beta) / (lat.a * lat.c))
for plane in self.planes:
spacing = calculations.planespacing(plane, self.monoclinic)
expected_spacing = 1.0 / sqrt(equation(self.monoclinic, *plane))
self.assertAlmostEqual(spacing, expected_spacing)
def testinterplanarangle_trigonal(self):
lat = self.trigonal
v = lat.a**3 * sqrt(1 - 3 * cos(lat.alpha)**2 + 2 * cos(lat.alpha)**3)
equation = lambda lat, h1, k1, l1, h2, k2, l2: \
(lat.a ** 4 * d1 * d2) / v ** 2 * \
(sin(lat.alpha) ** 2 * (h1 * h2 + k1 * k2 + l1 * l2) + \
(cos(lat.alpha) ** 2 - cos(lat.alpha)) * \
(k1 * l2 + k2 * l1 + l1 * h2 + l2 * h1 + h1 * k2 + h2 * k1))
for plane1 in self.planes:
for plane2 in self.planes:
d1 = calculations.planespacing(plane1, lat)
d2 = calculations.planespacing(plane2, lat)
angle = calculations.interplanarangle(plane1, plane2,
self.trigonal)
args = copy.deepcopy(plane1)
args.extend(plane2)
expected_angle = acos(equation(self.trigonal, *args))
self.assertAlmostEqual(angle, expected_angle, 6)
def testplanespacing_monoclinic(self):
equation = lambda lat, h, k, l: \
(1.0 / sin(lat.beta) ** 2) * \
(h ** 2 / lat.a ** 2 +
k ** 2 * sin(lat.beta) ** 2 / lat.b ** 2 + \
l ** 2 / lat.c ** 2 - \
2 * h * l * cos(lat.beta) / (lat.a * lat.c))
for plane in self.planes:
spacing = calculations.planespacing(plane, self.monoclinic)
expected_spacing = 1.0 / sqrt(equation(self.monoclinic, *plane))
self.assertAlmostEqual(spacing, expected_spacing)
def testplanespacing(self):
# Example 2.3
hkl = plane.Plane(3, 1, 2)
self.assertAlmostEqual(calculations.planespacing(hkl, self.L2), 1.964, 3)
def testplanespacing(self):
# Example 2.3
hkl = plane.Plane(3, 1, 2)
self.assertAlmostEqual(calculations.planespacing(hkl, self.L2), 1.964,
3)
