def test_iterable(self):
""" Make sure the chain is iterable.
"""
l1 = ElementaryLine([0.0, 1.2, 0.7])
l2 = ElementaryLine([0.0, 1.0, 0.5])
chain = EPChain([l1, l2])
for l in chain:
self.assertTrue(isinstance(l, ElementaryLine))
def test_membership(self):
""" Test the `in` operator.
"""
l1 = ElementaryLine([0.0, 1.2, 0.7])
l2 = ElementaryLine([0.0, 1.0, 0.5])
chain = EPChain([l1])
self.assertTrue(l1 in chain)
self.assertFalse(l2 in chain)
def test_construction_and_query(self):
""" Test we can construct EPChain object correctly.
"""
l1 = ElementaryLine([0.0, 1.2, 0.7])
l2 = ElementaryLine([0.0, 1.0, 0.5])
l = EPChain([l1, l2])
# Now the l2 should be translated.
self.assertTupleEqual(l2.eigen_points.A, (3.0, 0.69999999999999996))
def test_translate(self):
""" Make sure all lines in chain can be translated correctly.
"""
l1 = ElementaryLine([0.0, 1.2, 0.6])
l2 = ElementaryLine([0.0, 1.0, 0.8])
chain = EPChain([l1, l2])
chain.translate(1.0, "x").translate(1.0, "y")
self.assertTupleEqual(l1.eigen_points.A, (1.0, 1.0))
self.assertTupleEqual(l2.eigen_points.A, (4.0, 1.6000000000000001))
def test_add_lines(self):
canvas = EPCanvas()
l1 = ElementaryLine([0.0, 1.2, 0.6])
l2 = ElementaryLine([0.0, 1.0, 0.8])
canvas.add_lines([l1, l2])
canvas.lines = []
self.assertRaises(ValueError, canvas.add_lines, [l1, l1])
plt.close(canvas.figure)
def test_add_all_horizontal_auxiliary_lines(self):
""" Make sure we can add all horizontal auxiliary lines to canvas.
"""
canvas = EPCanvas()
l1 = ElementaryLine([0.0, 1.2, 0.6])
l2 = ElementaryLine([0.0, 1.0, 0.8])
canvas.add_lines([l1, l2])
canvas.add_all_horizontal_auxiliary_lines()
plt.close(canvas.figure)
def test_contains(self):
canvas = EPCanvas()
l1 = ElementaryLine([0.0, 1.2, 0.6])
l2 = ElementaryLine([0.0, 1.0, 0.8])
chain = EPChain([l1])
canvas.add_chain(chain)
self.assertTrue(l1 in canvas)
self.assertTrue(chain in canvas)
self.assertFalse(l2 in canvas)
plt.close(canvas.figure)
def test_append(self):
""" Make sure the elementary line can be appended properly.
"""
l1 = ElementaryLine([0.0, 1.2, 0.7])
l2 = ElementaryLine([0.0, 1.0, 0.5])
l = EPChain([l1])
l.append(l2)
# Check the l2 should be translated.
self.assertTupleEqual(l2.eigen_points.A, (3.0, 0.69999999999999996))
# Appending a repeated line will raise an exception.
self.assertRaises(ValueError, l.append, l2)
def test_construction_and_query(self):
""" Test we can construct ElementaryLine object correctly.
"""
line = ElementaryLine([0.0, 1.2, 0.7], n=2)
ret_x = line.x.tolist()
ref_x = [0.0, 1.0, 1.0, 2.0, 2.0, 3.0]
self.assertListEqual(ret_x, ref_x)
ret_y = line.y.tolist()
ref_y = [0.0, 0.0, -3.4426554548552387e-18, 0.7, 0.7, 0.7]
self.assertListEqual(ret_y, ref_y)
self.assertIsNone(line.rxn_equation)
self.assertEqual(line.color, "#000000")
self.assertEqual(line.shadow_color, "#595959")
self.assertEqual(line.shadow_depth, 0)
self.assertEqual(line.hline_length, 1.0)
self.assertEqual(line.interp_method, "spline")
self.assertEqual(line.n, 2)
self.assertEqual(line.peak_width, 1.0)
# Check invalid reaction equation.
self.assertRaises(ValueError,
ElementaryLine, [0.0, 1.2, 0.7],
rxn_equation="A + B -> C")
# Check invalid interpolation algorithm.
self.assertRaises(ValueError,
ElementaryLine, [0.0, 1.2, 0.7],
interp_method="abc")
# Check invalid energy tuple.
self.assertRaises(ValueError, ElementaryLine, [0.0, 1.2, 1.5])
def test_add_energy_annotations(self):
""" Make sure the energy annotations can be added correctly.
"""
canvas = EPCanvas()
line = ElementaryLine([0.0, 1.3, 0.8])
canvas.add_lines([line])
canvas.add_energy_annotations(line)
plt.close(canvas.figure)
def test_add_vertical_auxiliary_line(self):
""" Make sure the vertical line can be added without exceptions.
"""
canvas = EPCanvas()
line = ElementaryLine([0.0, 1.3, 0.8])
canvas.add_lines([line])
canvas.add_vertical_auxiliary_lines(line)
plt.close(canvas.figure)
def test_draw(self):
""" Make sure the lines can be added without exceptions.
"""
canvas = EPCanvas()
line = ElementaryLine([0.0, 1.3, 0.8])
canvas.add_lines([line])
canvas.draw()
plt.close(canvas.figure)
def test_x_y_data(self):
""" Test we can get correct data points.
"""
l1 = ElementaryLine([0.0, 1.2, 0.5], n=2)
l2 = ElementaryLine([0.0, 0.8], n=2)
chain = EPChain([l1, l2])
ref_x = [0.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0]
ret_x = chain.x.tolist()
self.assertListEqual(ref_x, ret_x)
ref_y = [
0.0, 0.0, 1.7213277274276194e-18, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,
1.3, 1.3, 1.3
]
ret_y = chain.y.tolist()
self.assertListEqual(ref_y, ret_y)
def test_add_species_annotations(self):
""" Make sure the species annotations can be added without exceptions.
"""
canvas = EPCanvas()
line = ElementaryLine(
[0.0, 1.3, 0.8],
rxn_equation="CO_b + O_b <-> CO-O_2b -> CO2_g + 2*_b")
canvas.add_lines([line])
canvas.add_species_annotations(line)
plt.close(canvas.figure)
def test_add_line(self):
""" Test the line can be add to canvas correctly.
"""
canvas = EPCanvas()
l1 = ElementaryLine([0.0, 1.2, 0.6])
canvas.add_line(l1)
# Add repeat line, exception raises.
self.assertRaises(ValueError, canvas.add_line, l1)
plt.close(canvas.figure)
def test_add_chain(self):
""" Test energy profile chain can be added correctly to canvas.
"""
canvas = EPCanvas()
self.assertFalse(canvas.lines)
self.assertFalse(canvas.chains)
l1 = ElementaryLine([0.0, 1.2, 0.6])
l2 = ElementaryLine([0.0, 1.0, 0.8])
chain = EPChain([l1, l2])
canvas.add_chain(chain)
self.assertEqual(len(canvas.lines), 2)
for l in canvas.lines:
self.assertTrue(isinstance(l, ElementaryLine))
self.assertEqual(len(canvas.chains), 1)
self.assertTrue(isinstance(canvas.chains[0], EPChain))
# Exception is expected if add the chain again.
self.assertRaises(ValueError, canvas.add_chain, chain)
plt.close(canvas.figure)
def test_eigen_pts(self):
""" Test we can get correct eigen points for an elemnetary line.
"""
line = ElementaryLine([0.0, 1.2, 0.8])
eigen_pts = line.eigen_points
self.assertTrue(eigen_pts.has_barrier)
self.assertTupleEqual(eigen_pts.A, (0.0, 0.0))
self.assertTupleEqual(eigen_pts.B, (1.0, 0.0))
self.assertTupleEqual(eigen_pts.C,
(1.5151515151515151, 1.2008062953822003))
self.assertTupleEqual(eigen_pts.D, (2.0, 0.80000000000000004))
self.assertTupleEqual(eigen_pts.E, (3.0, 0.80000000000000004))
line = ElementaryLine([0.0, 0.8])
eigen_pts = line.eigen_points
self.assertFalse(eigen_pts.has_barrier)
self.assertTupleEqual(eigen_pts.A, (0.0, 0.0))
self.assertTupleEqual(eigen_pts.B, (1.0, 0.0))
self.assertTupleEqual(eigen_pts.C, (2.0, 0.80000000000000004))
self.assertTupleEqual(eigen_pts.D, (2.0, 0.80000000000000004))
self.assertTupleEqual(eigen_pts.E, (3.0, 0.80000000000000004))
def test_translate_state(self):
""" Test we can translate specific state correctly.
"""
line = ElementaryLine([0.0, 1.3, 0.8])
# Translate IS.
line.translate_state("IS", -0.2)
self.assertEqual(line.y[0], -0.2)
# Translate TS.
ref_y = line.eigen_points.C[1] + 0.1
line.translate_state("TS", 0.1)
self.assertAlmostEqual(ref_y, line.eigen_points.C[1], places=2)
# Translate FS.
ref_y = line.eigen_points.E[1] - 0.2
line.translate_state("FS", -0.2)
self.assertAlmostEqual(ref_y, line.eigen_points.E[1], places=2)
# Check invalid state name.
self.assertRaises(ValueError, line.translate_state, "asd", 0.3)
def test_translate(self):
""" Make sure all points in line can be translated correctly.
"""
line = ElementaryLine([0.0, 1.2, 0.7], n=2)
line.translate(0.5, "x")
ref_x = [0.5, 1.5, 1.5, 2.5, 2.5, 3.5]
self.assertListEqual(line.x.tolist(), ref_x)
line.translate(-0.5, "y")
ref_y = [
-0.5, -0.5, -0.5, 0.19999999999999996, 0.19999999999999996,
0.19999999999999996
]
self.assertListEqual(line.y.tolist(), ref_y)
# Create chains.
chains = []
for idx, (energy_tuples, hline_lengths, peak_widths, color, initial_x,
initial_y) in enumerate(
zip(locs["multi_energy_tuples"], locs["hline_lengths"],
locs["peak_widths"], locs["colors"], locs["initial_xs"],
locs["initial_ys"])):
lines = []
for hline_length, peak_width, energies in zip(hline_lengths, peak_widths,
energy_tuples):
# Create an elementary line.
line = ElementaryLine(energies,
hline_length=hline_length,
peak_width=peak_width,
line_width=line_width,
color=color,
shadow_depth=locs["shadow_depth"],
shadow_color=locs["shadow_color"])
lines.append(line)
chain = EPChain(lines)
chain.translate(initial_x, "x")
chain.translate(initial_y, "y")
chains.append(chain)
# Export data.
filename = "data_{}.csv".format(idx)
chain.export(filename)
print("INFO: write data for chain_{} to {}".format(idx, filename))
def test_scales(self):
""" Test scales for x and y values.
"""
line = ElementaryLine([0.0, 1.2, 0.6])
self.assertEqual(line.scale_x, 3.0)
self.assertEqual(line.scale_y, 1.2003292394429861)
